각 문자열의 문자가 같은 횟수와 두 번 이상 나타나면 문자열이 구별되지 않는다고 말합니다 .

예

• "aa!1 1 !a !1"되는 비 차별 문자의 각 있기 때문에 , !, a그리고 1세 번 나타납니다.
• "abbaabb"되어 있지 않은 차별 때문에 b보다 더 자주 나타납니다 a.
• "abc"또한 하지 않은 차별 문자가 두 번 이상 표시되지 않습니다 때문이다.

태스크

쓰기 비 차별 프로그램이나 기능 반환 truthy 주어진 문자열 인 경우 값을 비 차별 및 falsy 그렇지 않으면 값입니다.

즉, 자체 소스 코드에서 실행되는 프로그램은 정확한 값을 반환해야합니다.

각 제출은 인쇄 가능한 ASCII를 포함하는 비어 있지 않은 문자열 과 제출의 소스 코드에 나타나는 모든 문자 를 처리 할 수 ​​있어야합니다 .

테스트 사례

진실한 :

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

Brachylog , 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

자바 (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]);}

온라인으로 사용해보십시오.
문자의 발생을 확인하는 데 사용되는 코드 , 이 도전에 대한 나의 대답 .

주석을 제거하고 엉망으로 만들어 @ OlivierGrégoire에게 다시 5 바이트 감사합니다 . ;)

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

온라인으로 사용해보십시오.
주석을 제외한 문자의 발생을 확인하는 데 사용되는 코드 . 이 도전에 대한 나의 대답이었습니다 .

@ OliverGrégoire< 가 수표를로 교체하여 제거 하여 -6 바이트 >.

기본 골프 프로그램에 대한 설명 (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.
• 6x를 제거 하도록 if-check e>0&u!=e|u<2를 변경했습니다 .!(e<2|u==e)|u<2&
• 두 개의 분리 된 수익을 제거하고 플래그를 사용 f하고, 우리는 (이 내가 6 배를 제거 할 수 있습니다 의미 결국 여전히 0인지 여부를 반환 by에서 byte우리 만 사용하는 것이 지금 n에 int대신 8의 6 배).
• e<2및 u<2변경 2>e과 2>u6 배를 제거합니다 <.

문자 수를 6에서 5로 줄이기 위해 한 것 :

• 배 int에이 byte정도의 양을 n사용하는 대신에 4 6이다.
• x[0]새 변수 대신 사용 f=0되므로 =사용되는 양은 6 대신 5입니다.
• 사용량 이 6이 아닌 2로 변경 2222되었습니다 .33332
• 변수 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

Brachylog , 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.

다음 t대신에 재사용되는 대체 12 바이트 솔루션 ᵐ:

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

T-SQL, 320 바이트 (32 자 x 10)

입력은 기존의 테이블을 통해입니다 FILLVARCHAR 필드와 함께 STEW, 우리의 IO의 기준에 따라 .

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

나는 한 번의 코드로 더 기뻐했지만 끔찍한 적이 없었습니다.

대소 문자 구분 데이터 정렬로 설정된 서버 또는 데이터베이스에서 실행해야합니다. 대문자와 소문자 E(SQL 명령은 대소 문자를 구분하지 않으므로 필요에 따라 몇 개 뒤집어 짐), 공백 및 탭 (가독성을 위해 탭은 위의 코드에서 줄 바꿈으로 표시됨)을 포함하여 32 개의 각기 다른 10 개의 문자 가 있습니다.

+ = ,코드에 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) ,  333168  바이트

9 바이트를 절약 한 @Kevin Cruijssen과 45 바이트를 절약 한 @Laikoni에게 감사드립니다!

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Ë*

온라인으로 사용해보십시오!

프로그램은 본질적으로 첫 번째 부분의 목표가 실제 작업을 수행하는 것이고 두 번째 부분의 목표는 결과를 변경하지 않고 첫 번째 부분과 동일한 기능을 사용하는 두 부분으로 나뉩니다.

설명 (1 부)

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?

파이썬 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 바이트 (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]]. 사본을 삭제해도 결과 행렬은 여전히 ​​직사각형이므로를 사용하여 다시 되돌릴 수 있습니다 \. 그러나 행렬이 직사각형 인 이유는 모든 입력 문자가 구별 되었기 때문에 결과 행렬에는 남아있는 요소가 없으며 "0x0"행렬을 직사각형으로 처리 \하지 않습니다 (실패). 따라서 oḅ\k\입력에 나타나는 각 문자가 같은 횟수로 나타나고 그 횟수는 1이 아니라고 효과적으로 주장합니다.

즉 (전체 프로그램으로, 우리가 얻을 우리 프로그램의 전체 기능의 true더 어설 션 오류가 발생하지 않는 경우, false어떤 한 경우). 우리는하지만, 소스 레이아웃 제한을 순종해야합니까, 그래서 추가로 추가 koḅ아무런 목적이없는 그이지만 실패 (달리 할 수없는 \, o그리고 ḅ빈 목록에 역할을 드리겠습니다을).

파이썬 2 , 84 80 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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

온라인으로 사용해보십시오!

이것은 골프에 큰 재미이었다. 한계는 $최소 4 개 (입력 $args용 1 개, 계산 결과 할당 $qe용 1 개, 마지막 문자 $qe[-1]확인 용 1 개, 첫 번째 문자 확인 용 1 개)가 필요 $qe[0]했기 때문에 작업 가능한 최대 문자 수였습니다.

거기에서 프로그램을 4로 나눌 수있는 것은 골프의 문제였습니다. #누락 된 요소를 설명하기 위해 작은 주석 (을 따르는 모든 것 )이 있지만 가능한 한 작은 주석을 유지하려고했습니다.

하스켈, 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

온라인으로 사용해보십시오!

파이썬 (2) , 108 (104) 92 88 바이트

Rod 덕분에 -12 바이트, Kevin Cruijssen
덕분에 -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

입력은 작은 따옴표로 묶인 문자열입니다. 문자열에서 작은 따옴표는 복제하여 이스케이프됩니다.

출력은 비어 행렬이다 truthy 이 제로를 포함하지 않는 경우, 및 falsy 이 적어도 0을 포함하는 경우.

온라인으로 사용해보십시오! 또는 편의를 위해 표준 진실성 / 거짓 성 테스트를 포함하여 모든 테스트 사례를 확인하십시오 .

작동 원리

로 표시된 진술 (*)은 필요하거나 유해하지 않으며 소스 코드를 차별하지 않도록 만들기 위해 포함되었습니다.

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 , -p57 바이트

각 문자는 3 번 나타납니다. 단 하나만 1아무것도하지 않습니다

기본 45 자 솔루션에 12 바이트를 추가하여 차별하지 않음

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)것과 동등한 것을 발견했습니다 . 나는 구출 할 수 와 육각 / 8 진수 코드와 트릭을 ; 가장 골치 아픈 해결책은에 대해 (백틱으로) 사용하는 것입니다 .xtabs(~foo)entu\164f8ToI\x6Etutf8ToInt

Brachylog , 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, 132116 바이트

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

주석이나 불필요한 문자열도 포함하지 않지만 코드 골프에서 함수를 호출하는 유일한 시간 일 것입니다 crudcardounenforceableuploads. 아마도 함수명에 대한 훌륭한 아나그램이있을 것입니다! 이름에 사용 된 멋진 아나그램 솔버를 지적 해 주신 John Dvorak에게 감사드립니다.

문자표 :

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

BASH 144 바이트

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

이 코드 줄은 stdin 문자열을 입력으로 사용합니다. "grep -o." 각 문자를 새 줄에 넣습니다. "uniq -c"는 각 체커의 사용량을 계산합니다. awk 스크립트는 각 사용법이 다른 요소 인 배열을 작성하고 배열 인덱스가 하나만 있고 값이 2 이상인 경우 true를 출력합니다. 각 문자는 4 번 사용되므로이 소스는 true를 리턴합니다.

Stax , 26 24 18 바이트

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

온라인으로 사용해보십시오!

MATL에서 구한 인쇄 가능한 ASCII 만 사용하는 지금까지 가장 짧은 솔루션 .

내가 문제에 잘못 접근하고 있다고 생각합니다. 작업 블록을 반복하는 것은 골프도 재미도 아닙니다. 이제 적어도 더 좋아 보입니다 ...

설명

: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

No-ops가 적은 대체 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 바이트

false이면 출력이 비어 있고 true이면 비어 있지 않습니다.

***???;;;;```!!$$$$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);}}}}}}}

온라인으로 사용해보십시오!

문자열의 주소를 정확한 값으로, 0을 거짓으로 반환합니다.

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.

펄 6 , 58 57 바이트

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

온라인으로 사용해보십시오!

세 문자 버전이 두 문자 버전보다 약간 짧습니다.