Недискриминационное программирование

74

Мы говорим, что строка недискриминационная, если каждый из символов строки появляется одинаковое количество раз и, по крайней мере, дважды.

Примеры

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

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>"
Laikoni
источник
4
@ Laikoni, мы можем злоупотреблять комментариями, чтобы заставить это работать?
Волшебный осьминог Урна
6
Как примечание, я люблю проблемы, где я могу использовать другие записи, чтобы проверить правильность моей записи.
Волшебный осьминог Урна
3
@MagicOctopusUrn Я думаю, что он сказал в песочнице, что это разрешено, так как это не может быть заметно установлено.
Эрик Outgolfer
11
Именно так. Даже если вам удастся как-то объективно запретить комментарии, то как насчет неиспользуемых строковых литералов? Во всяком случае, я думаю, что оценка дает стимул избегать комментариев как можно больше.
Лайкони
4
Я понимаю, что это всего лишь загадка, но связь «недискриминации» со «всеми идентифицируемыми типами элементов с метками, существующими в абсолютно равных частях», слегка тревожит ... «Различать» означает «различать» и несправедливо делать это означает обращаться с кем-либо или судить о нем несправедливо, основываясь на том, что он считает их отличными от людей другого класса. Конечно, продолжайте веселиться!
ErikE

Ответы:

37

Брахилог , 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
H.PWiz
источник
25

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 байт (char-count 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изменил на 2>eи 2>uудалить 6x <.

Что я сделал, чтобы уменьшить количество символов от 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
  • Добавляем {}циклы for и ifs и добавляем неиспользуемый {}блок.
  • Меняется !на !!!.
  • Меняется |на ||.
  • Изменение, 333чтобы +333-3|2избавиться от оставшихся арифметических операторов +-|и 2.
  • Меняется !(x[0]>0)на !!(0>--x[0]).
Кевин Круйссен
источник
1
180 байт : все изменилось<на>.
Оливье Грегуар
@ OlivierGrégoire Извините, я уже в 174 :) Но посмотрим, можно ли применить ваш трюк.
Кевин Круйссен
Изменение может применяться для сохранения 6 байтов.
Оливье Грегуар
Ближайший я к 162 символам (161 символ) . Я пытаюсь удалить комментарий, но мне все еще нужно где-то поставить запятую. Я просто не могу найти место.
Оливье Грегуар
1
160 байтов ( доказательство ). Очень вероятно более пригодный для игры в гольф.
Оливье Грегуар
15

Желе , 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
Деннис
источник
13

Брахилог , 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ℕ₂ℕ₂ọᵐ
Мартин Эндер
источник
13

T-SQL, 320 байтов (32 символа x 10 каждый)

Ввод осуществляется через уже существующую таблицу FILLс полем varchar 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 в зависимости от того, является ли входная строка недискриминационной.

BradC
источник
11

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

Даже bytecount не дискриминирует!

Попробуйте онлайн!

Steadybox
источник
Оооо ... Я хотел быть первым обидчиком комментария. Хороший хотя, мне нравится, как Вы сортировали символы для комментария ^ _ ^
Волшебная Урна Осьминога
1
Вы можете понизить его до 324 байт , изменяя как 128к 222так 8можно опустить.
Кевин Круйссен
1
279 байт путем переименования i, v, S, sи Lк персонажам , которые уже появляются в ключевых словах char, forи return: Try его в Интернете!
Laikoni
@Laikoni Спасибо! У меня не было времени, чтобы правильно сыграть в гольф вчера.
Steadybox
@MagicOctopusUrn Они отсортированы, потому что мне было лень добавлять их вручную .
Steadybox
9

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)
Emigna
источник
{γ€gDË*P≠qq{γ€gDË*P≠это еще за 20;).
Волшебный осьминог Урна
1
@MagicOctopusUrn: Отлично! У меня была пара других в 20 лет. У меня тоже есть один в 18 лет :)
Emigna
2
КОЛДОВСТВО! Никаких других объяснений!
Волшебный осьминог Урна
1
¢... хорошая идея, чувак, и я рад, что это было так же полезно, как я думал, это может быть, ха-ха!
Волшебный осьминог Урна
9

Шелуха , 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?
Zgarb
источник
Но это имеет «и» больше, чем «м», поэтому он не соответствует требованиям.
WGroleau
@WGroleau mтакже встречается дважды: в первой и во второй. Объяснение не включает две короткие строки, потому что они не влияют на поведение программы.
Згарб
Я полагаю, что ОП должен уточнить, можно ли отсканировать объяснение программы вместе с программой. Но на самом деле, если вы
включите
Неважно; это смутило меня так же, как и другой ответ.
WGroleau
9

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 (количество символов неодинаковое).

Попробуйте онлайн!

Деннис
источник
Трюк с отрицательной ошибкой сдвига аккуратен! Мне нравится, как он использует преимущество низкого приоритета оператора сдвига.
Винсент
1
{{e.dil:-tu,r.dil:-tu,}} Боже мой, что это?
Адам Барнс
1
@AdamBarnes Синтаксически допустимый трюк, который выдает ошибку NameE, если оценивается.
Деннис
Я не понимаю Я попытался обменять это, aи все сломалось. Не могли бы вы объяснить подробнее, пожалуйста?
Адам Барнс
@AdamBarnes Это должно работать, если вы оставите пробел после or. Я добавлю объяснение, когда я за компьютером.
Деннис
9

Brachylog v2, 8 байт (в наборе символов Brachylog)

oḅ\k\koḅ

Попробуйте онлайн!

Похоже, в Brachylog идет игра в гольф по этому вопросу, поэтому я решил присоединиться, сэкономив пару байтов для следующего лучшего ответа.

Это полная программа, которая принимает ввод в виде списка кодов символов. (Это отчасти потому, что в 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и мы рады действовать в пустых списках).

оборота ais523
источник
1
Это язык этого месяца !
Эрик Outgolfer
7

Python 2 , 84 80 байт

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

Попробуйте онлайн!

Винсент
источник
+1 для короткого кода Python без ошибок и нашей оперативной утопии;)
Shieru Asakoto
7

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.
Сиеру Асакото
источник
6

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], так что это было максимальное рабочее число символов).

Оттуда, это было вопросом игры в гольф (а не игры в гольф, как наличие двухбуквенного имени переменной), чтобы программа делилась на четыре. Обратите внимание, что у нас есть небольшой комментарий (все, что следует за #), чтобы учесть некоторые недостающие элементы, но я постарался сделать комментарий как можно меньше.

AdmBorkBork
источник
6

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

Попробуйте онлайн!

Ними
источник
6

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

Попробуйте онлайн!

овс
источник
1
Ваша программа должна быть недискриминационной.
user202729
1
Сама программа должна быть недискриминационной.
HyperNeutrino
@ user202729 Спасибо, что сказали мне, я обновил свой ответ.
овс
1
s=input();c=s.count;print[all(c(s[[]>[1]])>=c(o)>1. for o in s)];aaafffillpprrtuu=1.>1.; 88 байтов , избавившись от комментария.
Кевин Круйссен
6

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
Луис Мендо
источник
5

Perl 5 , -p57 байт

Каждый персонаж появляется 3 раза. Только один 1ничего не делает

12 байтов добавлены к базовому 45-символьному решению, чтобы сделать его недискриминационным

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

Попробуйте онлайн!

Тон Хоспел
источник
5

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.

Робин Райдер
источник
Впечатляет, что вы можете различать эти два случая в 90 байтах (и приятно злоупотреблять оператором справки), но, увы, NAэто не считается истинным значением (в R, если (NA) x иначе y вызывает ошибку, то NAесть не является ни правдивым, ни ложным) )
JDL
1
@JDL Спасибо, ты прав. Последняя редакция исправляет эту проблему.
Робин Райдер
1
@JDL комментарии предполагают, что последовательные, четкие ответы подходят для правдивых и ложных.
Джузеппе
@Giuseppe На самом деле, я решил эту проблему несколько секунд назад (см. Новую версию, которая совершенно другая, но с тем же количеством байтов); теперь выводит TRUE и FALSE.
Робин Райдер
4

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

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

Попробуйте онлайн!

К сожалению, я не могу удалить переводы строки, так как на число вызывает сбой.

Эрик Аутгольфер
источник
Определенно возможно сделать что-то более короткое, не требующее перевода строки (но вам, возможно, придется изменить некоторые вещи);)
Fatalize
@Fatalize Сейчас нет времени, и да, я читал эту дискуссию. :)
Эрик Outgolfer
4

Рубин , 87 78 байт

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

26 символов повторяются 3 раза каждый

Попробуйте онлайн!

Асоне Тухид
источник
@nimi Спасибо за указание на это, я думаю, это было странно с getsи ;. Поменял его, короче лямбда все равно
Asone Tuhid
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
JDL
источник
не знаю, важно ли количество байтов, но мы, вероятно, можем удалить 2 и >s, переключив сравнение с f. Также можно использовать =вместо <<-. strsplitВероятно, это неизбежно, что является источником большинства других символов.
JDL
тебе нужны места? Вы также можете попробовать utf8ToIntвместо strsplit, но не уверены, поможет ли это. Также, возможно, включить ссылку на TIO?
Джузеппе
также все .кажется лишним.
Джузеппе
Это код-гольф , так что количество байтов важно для вашего комментария.
Джузеппе
2
некоторые возможные анаграммы: нет бюрократии в шкафу с пипсовкой; Рип из углеродистых шашлыков. Найдено с помощью wordplays.com/anagrammer
Джон Дворжак
2

BASH 144 байта

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

Эта строка кода принимает строку ввода в качестве ввода. "grep -o." помещает каждый символ в новую строку. "uniq -c" подсчитывает использование каждой главы. Сценарий awk создает массив с каждым использованием в качестве отдельного элемента и выводит значение true, если существует только 1 индекс массива, а значение равно как минимум 2. Каждый символ используется 4 раза, поэтому этот источник возвращает значение true

Калеб
источник
2

Stax , 26 24 18 байт

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

Попробуйте онлайн!

Самое короткое решение на данный момент, которое использует только печатные ASCIIs , побитые 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
Вейцзюнь Чжоу
источник
@WGroleau, какие символы появляются один раз? Вы достаточно внимательно прочитали мой ответ?
Вейцзюнь Чжоу
«#» появляется чаще, чем «:» (только один пример). Упс, неверное прочтение (см. Другой комментарий)
WGroleau
@WGroleau Есть ровно две #и две :, ты прочитал мой ответ во второй строке? Вы только что пропустили первый абзац в моем "Объяснении"?
Вейцзюнь Чжоу
Извините, думал, что строка выше объяснения была целым.
WGroleau
1

Пип , 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
DLosc
источник
1

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фактически никогда не оценивается)

Скрипт для проверки ответов:

12Me21
источник
1

Сетчатка 0.8.2 , 168 90 байт

Вывод будет пустым, если false, или непустым, если true.

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

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

Попробуйте онлайн

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

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

объяснение

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

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

mbomb007
источник
Хорошо, мой ответ короче, но я не уверен, что он хорошо масштабируется, чтобы быть зафиксированным для 0/1 в качестве вывода, поэтому я просто добавлю его здесь на случай, если он поможет вам: tio.run/##K0otycxLNPz/…
FryAmTheEggman
@FryAmTheEggman Я искал чистое решение для регулярных выражений, чтобы сопоставить группы символов одинаковой длины все подряд, но я не мог понять это.
mbomb007
@FryAmTheEggman Сделано большое улучшение! Я на самом деле не использовал то, что вы имели, но я начал с нуля, пытаясь придумать лучший метод.
mbomb007
Красиво сделано! Кажется, я не задумывался о своей программе, но, по крайней мере, вы нашли лучшую :)
FryAmTheEggman
1

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но я не могу найти один.

RK.
источник
1

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.
gastropner
источник