Ми говоримо, що рядок є недискримінаційним, якщо кожен із символів рядка з'являється однаково та щонайменше двічі.

Приклади

• "aa!1 1 !a !1"є недискримінаційний , так як кожен з символів , !, aі 1з'являється три рази.
• "abbaabb"це НЕ недискримінаційний , тому що bз'являється частіше a.
• "abc"також не є дискримінаційним, оскільки символи не з'являються щонайменше двічі.

Завдання

Напишіть недискримінаційну програму або функцію, яка повертає просте значення, якщо дана рядок не є дискримінаційною , а помилкове значення - в іншому випадку.

Тобто програма, запущена на власному вихідному коді, повинна повертати триєдине значення.

Кожне подання повинне вміти обробляти не порожні рядки, що містять ASCII для друку , а також усі символи, що відображаються у вихідному коді подання.

Випробування

Truthy:

<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"

Фальсі:

"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>"

Брахілог , 10 байт

=ᵍbᵐbᵐlᵍ=l

Спробуйте в Інтернеті!

Пояснення

=ᵍ                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 байт (кількість лічильників 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]);}

Спробуйте в Інтернеті.
Код, який використовується для перевірки подій персонажів , що було моєю відповіддю на це завдання .

-5 байт завдяки @ OlivierGrégoire знову, позбувшись коментаря та заблудившись . ;)

Старі 168 байт (символ-рахунок 6) Відповідь :

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::::{{{{{;;||||}}}}}>>

Спробуйте в Інтернеті.
Код, який використовується для перевірки подій персонажів, виключаючи коментар , який був моєю відповіддю на це завдання .

-6 байт завдяки видаленню @ OliverGrégoire< , замінивши чеки на >.

Пояснення базової програми для гольфу (98 байт):
Спробуйте в Інтернеті.

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

Деякі речі, які я зробив, щоб зменшити кількість використаних символів:

• Імена змінних o, w, u, f, r, і eбули обрані з метою повторного використання символів ми вже мали (але не більше 6).
• 2222використовується замість 256.
• Змінено якщо перевірити , e>0&u!=e|u<2щоб !(e<2|u==e)|u<2видалити 6х &.
• Вилучені два розділених повертаються і використовується прапор f, і ми повертаємося , чи є вона по- , як і раніше-в кінці (це означало , що я міг видалити 6й byз byteтепер , що ми використовуємо тільки nв int6 разів , а не 8).
• e<2і u<2змінено на 6x 2>eта 2>uвидалити його <.

Що я зробив, щоб зменшити кількість знаків від 6 до 5:

• 2x, intщоб byteкількість nвикористаних дорівнювала 4, а не 6.
• Використовується x[0]замість нової змінної, f=0тому кількість =використовуваної 5 замість 6.
• Змінений , 2222щоб 3333таким чином кількість 2використаного 2 замість 6.
• Змінені змінні, fі rзнову так, що їх теж не 6.

Що @ OlivierGrégoire зробив, щоб позбутися від коментаря, і тому 5x /:

• Додавання невикористаних змінних ,i,fe,fi,w;.
• Додавання невикористовуваних ярликів: s:w:no0r3sswwyyy:.
• Додавання невикористаного |2>2
• Додавання {}навколо-циклів та ifs та додавання невикористаного {}-блока.
• Зміна !на !!!.
• Зміна |на ||.
• Зміна, 333щоб +333-3|2позбутися залишків арифметичних операторів +-|і 2.
• Зміна !(x[0]>0)на !!(0>--x[0]).

Желе , 18 16 12 10 байт

Ġ¬zḊḊ¬zĠȦȦ

Спробуйте в Інтернеті!

Як це працює

Ġ¬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

Брахілог , 14 12 байт

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

Спробуйте в Інтернеті!

Пояснення

ọ   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.

Альтернативне 12-байтове рішення, яке повторно використовується tзамість ᵐ:

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

T-SQL, 320 байт (32 символи х 10 кожен)

Введення здійснюється за допомогою попередньо існуючої таблиці FILLз варчарським полем STEW, згідно з нашими стандартами введення-виведення .

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)----------<<<<<<

Мені ніколи не було більше приємно, але в жахливості від коду.

Потрібно запустити на сервері або базі даних, встановлених для регістру, залежно від регістру Налічується 10 кожного з 32 різних символів, включаючи верхній і нижній регістри E(команди SQL не залежать від регістру, тому переверніть декілька за потребою), пробіли та вкладки (вкладки показані у вигляді розривів рядків у коді вище, для читабельності).

Я знайшов способи включити по 10 інших символів + = ,у код, але, на жаль, не зміг знайти спосіб зробити це <, тому мені довелося додати символ коментаря -.

Ось відформатований код, перш ніж я забився у всіх додаткових наповнювачах:

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)

Верхній рядок - це рекурсивний CTE, який генерує таблицю чисел b, яку ми приєднуємо до вихідного рядка, щоб розділити за символом. Ці символи згруповані та підраховані, і IIFоператор повертає 0 або 1 залежно від того, чи вводить рядок недискримінаційним.

C (gcc) ,  333  168 байт

Дякуємо @Kevin Cruijssen за збереження 9 байт і спасибі @Laikoni за збереження 45 байт!

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{{{{{{}}}}}}

Спробуйте в Інтернеті!

C, 333 байти

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{{{{{{{}}}}}}}

Навіть облік рахунків недискримінаційний!

Спробуйте в Інтернеті!

05AB1E , 20 18 16 14 байт

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

Спробуйте в Інтернеті!

Програма по суті розділена на 2 частини, де метою першої частини є виконання фактичного завдання, а мета другої частини - використовувати ті ж функції, що і перша частина, не змінюючи результат.

Пояснення (перша частина)

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

Пояснення (друга частина)

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)

Лушпиння , 14 байт

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

Спробуйте в Інтернеті!

Пояснення

Дві короткі лінії не мають функцій, оскільки основна функція їх ніколи не викликає.

§<ε#ε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 байт

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

Вихід здійснюється через наявність або відсутність помилки. Помилка є або ValueError (один або більше символів трапляються лише один раз) або NameError (кількість символів неоднакова).

Спробуйте в Інтернеті!

Brachylog v2, 8 байт (у наборі символів Брахілог)

oḅ\k\koḅ

Спробуйте в Інтернеті!

Схоже, що в Брахілозі на це питання триває війна з гольфом, тому я подумав, що приєднаюся, заощадивши пару байтів на наступній найкращій відповіді.

Це повна програма, яка приймає дані як список кодних символів. (Частково тому, що, здається, у Brachylog є дуже химерні помилки, пов’язані з косою рисою рядків, а частково тому, що \команда не працює у списках рядків.)

Пояснення

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ḅЗрештою , це не має значення; kзавжди буде мати елемент, на який можна діяти, oі ḅне може вийти з ладу, якщо йому буде наданий список як вхідний.

Причина початку oḅповинна бути зрозумілою; він розділяє список вхідних даних за значенням, наприклад [1,2,1,2,4,1], стане [[1,1,1],[2,2],[4]]. Для того, щоб кожен символ відображався однаковою кількістю разів, кожен із цих списків повинен бути однакової довжини, тобто отриманий список є прямокутником. Ми можемо стверджувати цю прямокутність, використовуючи \, що також переміщує рядки та стовпці як побічний ефект.

Тепер у нас є поточне значення, що складається з декількох копій набору символів, наприклад, якби введення було [4,2,1,2,4,1]поточним значенням [[1,2,4],[1,2,4]]. Якщо ми видалимо копію, отримана матриця залишається прямокутною, тому ми можемо повернути її за допомогою \. Однак, якщо причина , по якій матриця була прямокутної в тому , що всі вхідні символи були різні, то результуюча матриця не матиме жодних елементів, що залишилися, а \зовсім НЕ лікувати матрицю «0 × 0» в вигляді прямокутних (скоріше, він зазнає невдачі). Настільки oḅ\k\ефективно стверджує, що кожен символ, який з’являється на вході, з’являється однаковою кількістю разів, і ця кількість разів не дорівнює 1.

Ось і вся функціональність нашої програми (як повноцінна програма ми отримуємо, trueякщо жодних збоїв у твердженні не сталося, falseякщо такі були). Нам все ж дотримуватися обмеження щодо макета джерела, тому я додав додатковий, koḅякий не має мети, але який не може вийти з ладу (на відміну від цього \, oі ḅз радістю діють у порожніх списках).

Python 2 , 84 80 байт

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

Спробуйте в Інтернеті!

JavaScript (Node.js) , 144 ... 100 96 байт

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

Спробуйте в Інтернеті!

24 різні символи * 6 разів кожен

28 різних символів * 5 разів кожен

27 різних символів * 5 разів кожен

27 різних символів * 4 рази кожен

26 різних символів * 4 рази кожен

25 різних символів * 4 рази кожен

24 різні символи * 4 рази кожен

Пояснення

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 байти

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

Спробуйте в Інтернеті!

Це було велике задоволення від гольфу. Обмеження полягало в тому $, що нам потрібно чотири мінімум (один для введення $args, один для призначення результату обчислень $qe, один для перевірки останнього символу $qe[-1]та один для перевірки першого символу $qe[0], таким чином, це була максимальна робоча кількість символів.

Звідси було питання про гольф (а не гольф, як те, щоб мати назву змінної з двох літер), щоб програма добре розділилася на чотири. Зауважте, що у нас є невеликий коментар (усе, що випливає з цього приводу #) для врахування деяких відсутніх елементів, але я намагався залишати коментар якомога меншим.

Haskell, 90 75 72 байти

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

Кожен символ з'являється 6 разів. Рядок введення приймається як одиночний список .

Спробуйте в Інтернеті!

Для довідки, старі версії:

75 байт, кожен знак 5 разів

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

Спробуйте в Інтернеті!

90 байт, кожен знак 3 рази:

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

Спробуйте в Інтернеті!

Python 2 , 108 104 92 88 байт

-12 байт завдяки Род
-4 байтів завдяки Кевіну Крейсейну

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

Спробуйте в Інтернеті!

MATL , 12 байт

q&=sqt&=tsvv

Вхід - це рядок, укладений в окремі лапки. Одиничні лапки в рядку усуваються шляхом дублювання.

Вихід є не порожньою матрицею, яка є правдою, якщо вона не містить нулів, і є хибною, якщо вона містить принаймні нуль.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки , включаючи стандартний тест на правдивість / вірність для зручності.

Як це працює

Записи, позначені символом (*), не є ні необхідними, ні шкідливими, і включаються лише для того, щоб вихідний код не був дискримінаційним.

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 байт

Кожен символ з'являється 3 рази. Тільки один 1не робить нічого

12 байт додано до основного рішення з 45 символів, щоб зробити недискримінаційним

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

Спробуйте в Інтернеті!

R , 90 байт

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

Спробуйте в Інтернеті!

Виходи TRUEдля недискримінаційного рядка та FALSEдля дискримінаційного рядка. На цьому веб-сайті я написав багато негарного коду для викликів, але вважаю, що це найгидніше до цих пір.

45 символів, використаних двічі кожен (включаючи декілька в коментарі). Попередня найкраща відповідь R складала 116 байт , причому 29 символів використовувались 4 рази кожен; Я публікую це окремо, оскільки він суттєво відрізняється.

Код еквівалентний

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

який перетворює вхід у вектор цілих чисел, обчислює таблицю на випадок yзначень, потім перевіряє, чи всі підрахунки в цій таблиці дорівнюють першому підрахунку і що перший підрахунок більший за 1.

Початкова складність полягала у використанні лише 2 пар дужок. Це досягається шляхом перевизначення одинарних функцій !і ?бути, utf8ToIntі prodвідповідно. (Я не можу використовувати, allбо мені це потрібно a). Є чотири завдання: два з =і два з <-. Це означає, що тест на рівність між yі zне може використовувати y==zні y-z; y%in%zприходить на допомогу.

Визначення цих функцій використовує всі можливі цитати: дві подвійні лапки, дві одиничні лапки, і мені знадобляться дві основні позиції в наступному абзаці, тому мені довелося вдатися readLines()замість цього scan(,""). (Інші варіанти, такі як scan(,letters)або scan(,month.abb)всі, використовували дорогоцінний, t який я не міг позбавити.)

У цей момент у мене була більшість будівельних блоків: utf8ToInt, prod, table, readLines, %in%. Три символу з'являється три рази в цих іменах: ent. По-перше, я виявив, що table(foo)еквівалентно xtabs(~foo)збереженню e. Я можу врятувати nі tз шестигранною / восьмеричний код трюком ; найкращим рішенням є використання u\164f8ToI\x6Et(у задніх планах ) для utf8ToInt.

Брахілог , 18 байт

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

Спробуйте в Інтернеті!

На жаль, я не можу видалити канали ліній, оскільки ḅв деяких випадках спрацьовує помилка.

Рубі , 87 78 байт

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

26 символів повторювали 3 рази кожен

Спробуйте в Інтернеті!

R, 132 116 байт

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

Він не містить жодних коментарів і зайвих рядків, хоча, мабуть, це буде мій єдиний раз у коді гольфу, який викликає функцію crudcardounenforceableuploads. Напевно, там є чудова анаграма для назви функції! Дякую Джону Двораку за те, що він вказав на приємний аналог-вирішувач, який я використав для імені.

Таблиця символів:

- , ; ! " ( ) [ ] { } & < 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

приклади:

> 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

БАШ 144 байти

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

Цей рядок коду приймає рядок stdin як вхідний. "греп -о." ставить кожного символу в новий рядок. "uniq -c" підраховує використання кожної діаграми. Сценарій awk створює масив з кожним використанням як інший елемент і виводить true, коли є лише 1 індекс масиву, а значення принаймні 2. Кожен символ використовується 4 рази, тому це джерело повертає істинне

Стакс , 26 24 18 байт

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

Спробуйте в Інтернеті!

Найкоротше рішення поки що використовує тільки друковані ASCII, побиті MATL.

Гадаю, я підходив до проблеми неправильно. Повторення робочого блоку не є ні голодним, ні цікавим. Тепер принаймні це виглядає краще ...

Пояснення

:u{m* виробляє сміття, яке не впливає на вихід.

_{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

Піп , 22 байти

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

Спробуйте в Інтернеті!

Пояснення

Кожен символ зустрічається двічі.

                        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

Чергуйте 22-байтну версію з меншою кількістю відсутніх параметрів:

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

SmileBASIC, 164 152 148 140 байт

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

35 різних персонажів, повторених 4 рази кожен.

Жодних коментарів не використовували (але вираз після neXTцього ніколи не оцінюється фактично)

Сценарій для перевірки відповідей:

//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>

Сітківка 0,8,2 , 168 90 байт

Вихід буде порожнім, якщо помилковим, або не порожнім, якщо істинним.

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

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

Спробуйте в Інтернеті

Основна програма (39 байт)

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

Пояснення

Вся основна програма знаходиться в безшумному циклі. Перший етап сортує вхід. На другому етапі буде надруковано поточний рядок, якщо він складається з послідовних пар різних символів. Третій етап видаляє останнє виникнення кожного символу (видалення одного з кожного символу в рядку).

Про сміття вгорі: порядок важливий. Окрім необхідності бути синтаксично дійсним, крапка з комою повинна бути після зірочок та перед задніми позначками, доки вона *є у конфігураційному рядку, щоб вона не надрукувалась.

CoffeeScript 1 , 96 93 90 байт

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

Спробуйте в Інтернеті!

Почав з моєї відповіді ES6, але повернувся до використання Array.every. 32 31 30 жетонів @ 3 кожен

Pyth, 30 байт

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

Потрібні провідні місця.

Спробуйте в Інтернеті!

Фактична програма просто &q1lJ{hMrSz8<1hJ. Я просто заздалегідь випереджав струну, "&8<MQSlqr{"щоб зробити її недискримінаційною. Але щоб рядок не надрукував себе, мені довелося додати пробіл, тому я додав 2 пробіли.

&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_encodeтут ( r <any> 8) приймає послідовність і виводить довжину кожного прогону одного символу, напр. "aaabbcc"стає [[3, "a"], [2, "b"], [2, "c"]].

Таким чином, він бере вхід, сортує його, щоб укласти кодування по довжині, і бере перший елемент кожного списку в отриманому списку (наприклад, став би попередній приклад [3, 2, 2]). Це дає підрахунок, скільки разів зустрічаються символи. Потім він дедублюється (став би попередній приклад [3, 2]), і J встановлюється для цього.

Потім він перевіряє, чи довжина дорівнює 1, тобто є лише 1 унікальна кількість разів, коли символ виникає, і якщо це> 1, тобто> = 2.

Там може бути вбудованим , щоб замінити rSz8або , hMrSz8але я не можу знайти.

C (gcc) , 153 байт

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);}}}}}}}

Спробуйте в Інтернеті!

Повертає адресу рядка як триєдине значення, а нуль - як хибне.

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 байт

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

Спробуйте в Інтернеті!

Виходить версія трьох символів трохи коротша, ніж двома символами.