입력으로 문자열이 주어지면 가장 긴 연속을 찾으십시오. 두 번 이상 문자가없는 하위 문자열을 . 이러한 하위 문자열이 여러 개인 경우 출력 할 수 있습니다. 원하는 경우 입력이 인쇄 가능한 ASCII 범위에 있다고 가정 할 수 있습니다.

채점

답은 먼저 반복되지 않는 가장 긴 하위 문자열의 길이와 총 길이로 순위가 매겨집니다. 점수가 낮을수록 두 기준 모두 더 좋습니다. 언어에 따라 아마도 소스 제한이 코드 골프 도전과 .

하찮은 생각

1, x (언어) 또는 2, x 의 점수를 획득하는 일부 언어 (브레인 플랙 및 기타 타르타르 타프) 매우 쉬운 반면, 가장 긴 반복되지 않는 하위 문자열을 최소화하는 것이 어려운 다른 언어가 있습니다. Haskell에서 2 점을 획득하는 데 많은 즐거움이 있었으므로이 작업이 재미있는 언어를 찾아 보는 것이 좋습니다.

테스트 사례

"Good morning, Green orb!" -> "ing, Gre"
"fffffffffff" -> "f"
"oiiiiioiiii" -> "io", "oi"
"1234567890"  -> "1234567890"
"11122324455" -> "324"

채점 제출

다음 스 니펫을 사용하여 프로그램의 점수를 매길 수 있습니다.

input.addEventListener("input", change);

// note: intentionally verbose :)
function isUnique(str) {
  var maxCount = 0;
  var counts = {};
  for(var i = 0; i < str.length; i++) {
    var c = str.charAt(i);
    counts[c] |= 0;
    counts[c]++;
    if(maxCount < counts[c]) {
      maxCount = counts[c];
    }
  }
  return maxCount <= 1;
}

function maximizeSubstring(str, pred, cost) {
  var mostExpensive = -1;
  // iterate over substrings
  function iterate(start, end) {
    var slice = str.slice(start, end);
    if(pred(slice)) {
      var profit = cost(slice);
      if(profit > mostExpensive) {
        mostExpensive = profit;
      }
    }
    end++;
    if(start >= str.length) {
      return;
    }
    else if(end > str.length) {
      start++;
      iterate(start, start);
    }
    else {
      iterate(start, end);
    }
  }
  iterate(0, 0);
  return mostExpensive;
}

function size(x) {
  return x.length;
}

function longestNonRepeatingSize(str) {
  return maximizeSubstring(str, isUnique, size);
}

function change() {
  var code = input.value;
  output.value = "Your score is: " + longestNonRepeatingSize(code);
}

change();

* {
  font-family: monospace;
}

Input code here:
<br>
<textarea id="input"></textarea>
<br>
<textarea id="output"></textarea>

C, 점 (2),  747   (720)  662 바이트

L  [  1  <<  7  ]  ,  *  q  ,  *  r  ,  l  ,  d  ,  i  ,  c  ,  j  ,  s  ,  t  ,  k  =  1  <<  7  ;  h  (  )  {  q  =  s  +  i  +  j  ++  ;  *  q  %  k  &&  !  L  [  *  q  %  k  ]  ++  &&  h  (  ++  c  )  ;  }  g  (  )  {  q  =  s  +  i  ;  *  q  %  k  ?  z  (  k  )  ,  h  (  j  =  c  =  0  )  ,  c  >  d  &&  (  d  =  c  )  &&  (  l  =  i  )  ,  g  (  ++  i  )  :  0  ;  }  f  (  S  ,  T  )  {  s  =  S  ;  l  =  i  =  d  =  0  ;  g  (  t  =  T  )  ;  p  (  i  =  0  )  ;  }  p  (  )  {  q  =  s  +  l  +  i  ;  r  =  t  +  i  ;  i  ++  <  d  ?  p  (  *  r  =  *  q  )  :  (  *  r  =  0  )  ;  }  z  (  i  )  {  L  [  --  i  ]  =  0  ;  i  &&  z  (  i  )  ;  }

최소한 32 비트 MinGW에서 작동합니다 (최적화가 비활성화 된 상태). 단일 키워드를 사용하지 않습니다.

gcc 및 clang과 함께 TIO에서도 작동 합니다. 온라인에서 사용해보십시오!(감사합니다 @Dennis!)

전화 :

int main()
{
    char str[1024];

    f("Good morning, Green orb!", str);
    puts(str);

    f("fffffffffff", str);
    puts(str);

    f("oiiiiioiiii", str);
    puts(str);

    f("1234567890", str);
    puts(str);

    f("L  [  1  <<  7  ]  ,  *  q  ,  *  r  ,  l  ,  d  ,  i  ,  c  ,  j  ,  s  ,  t  ,  k  =  1  <<  7  ;  h  (  )  {  q  =  s  +  i  +  j  ++  ;  *  q  %  k  &&  !  L  [  *  q  %  k  ]  ++  &&  h  (  ++  c  )  ;  }  g  (  )  {  q  =  s  +  i  ;  *  q  %  k  ?  z  (  k  )  ,  h  (  j  =  c  =  0  )  ,  c  >  d  &&  (  d  =  c  )  &&  (  l  =  i  )  ,  g  (  ++  i  )  :  0  ;  }  f  (  S  ,  T  )  {  s  =  S  ;  l  =  i  =  d  =  0  ;  g  (  t  =  T  )  ;  p  (  i  =  0  )  ;  }  p  (  )  {  q  =  s  +  l  +  i  ;  r  =  t  +  i  ;  i  ++  <  d  ?  p  (  *  r  =  *  q  )  :  (  *  r  =  0  )  ;  }  z  (  i  )  {  L  [  --  i  ]  =  0  ;  i  &&  z  (  i  )  ;  }");
    puts(str);
}

산출:

약간 더 읽기 쉬운 형식의 코드 :

L[1<<7],
*q, *r, l, d, i, c, j, s, t, k=1<<7;

h()
{
    q = s+i+j++;
    *q%k && !L[*q%k]++ && h(++c);
}

g()
{
    q = s+i;
    *q%k ? z(k), h(j=c=0), c>d && (d=c) && (l=i), g(++i) : 0;
}

f(S, T)
{
    s = S;
    l = i = d = 0;
    g(t=T);
    p(i=0);
}

p()
{
    q = s+l+i;
    r = t+i;
    i++<d ? p(*r=*q) : (*r=0);
}

z(i)
{
    L[--i] = 0;
    i && z(i);
}

그리고 점수 2로 서식을 지정하기 위해 적절한 간격을 생성하는 데 사용할 수 있습니다. 온라인으로 사용해보십시오!

C, 점수 3, 309 바이트

i
,
j
,
l
,
c
,
d
;
f
(
\
c\
\
h\
\
a\
\
r
*
s
)
{
\
f\
\
o\
\
r
\
(
i
=
l
=
d
=
0
;
s
[
i
]
;
c
>
d
&&
(
d
=
c
)
&&
(
l
=
i
)
,
++
i
)
\
f\
\
o\
\
r
(
\
c\
\
h\
\
a\
\
r

L
[
\
1\
\
2\
\
8
\
]
=
{
j
=
c
=
0
}
;
s
[
i
+
j
]
&&
!
L
[
s
[
i
+
j
++
]
]
++
;
++
c
)
;
\
w\
\
r\
\
i\
\
t\
\
e
(
1
,
s
+
l
,
d
)
;
}

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

하스켈 2 득점 492 ... 307 224 212 209 207 바이트

((yy:yyy))??ss|ss==yy  =  ""  |  yy==yy=yy:yyy??ss
ss??sss=ss
ss""=""

ss((ff:fff))  =  ff  :  ss  fff??ff
ff""=""

ff((xxx:xx))  =  ss((xxx:xx))##ff  xx
xx##xxx  |  ((((xx>>xx))<))  $  xxx>>xx=xxx|xx==xx=xx

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

WW 와 Ørjan Johansen 덕분에 말 그대로 수백 바이트의 골프 !

설명

이 함수 (??)는 문자 c와 문자열을 가져와 포함하지 않는 s가장 긴 접두사를 반환 s합니다 c. 골퍼가없고 점수에 최적화되지 않은 경우 :

c ?? (y:s)  
    | c==y = ""
    | True = y : c ?? s
c ?? s = s

이 함수 ss는 (??)주어진 문자열에서 고유 한 문자의 가장 긴 접두사를 찾는 데 사용 합니다.

ss (x:r) = x : (x ?? ss r)
ss "" = ""

(##)두 개의 문자열을 사용하고 더 긴 문자열을 반환하는 함수입니다. 길이 비교 문자열을 반복하여 작동 x종종만큼 x긴 ( x>>y)과 같은 y길이 ( y>>x전적으로 큰 결과 스트링 함) 및 확인.

x ## y
  | (x>>x) < (y>>x) = y
  | True = x

마지막으로 ff입력 문자열을 통해 재귀하고을 사용하여 가장 긴 접두사를 생성하고 ss문자열 꼬리의 가장 긴 반복되지 않는 하위 문자열을 재귀 적으로 결정하고 다음을 사용하여 둘 중 더 긴 것을 반환합니다 (##).

ff "" = ""
ff (x:r) = ss(x:r) ## ff r

루아, 3, 274 바이트

g='g'..'s'..'u'..'b'  _G  [  'l'..'o'..'a'..'d'  ](  g[g  ](  "s  =...f  o  r d = # s - 1 , 0 , - 1 d  o f  or r = 1 , # s - d d  o t = s :s  ub  (r  ,r  +d  )i  f n  ot t:  fi  nd  '(  .)  .*  %1  't  he  n p  ri  nt  (t  )r  et  ur  n en  d e  n  d e  nd  ","  ",""))(...)

참고 : Lua 5.2 또는 Lua 5.3이 필요합니다

용법:

$ lua lnrs.lua "Good morning, Green orb!"
ing, Gre
$ lua lnrs.lua "fffffffffff"
f
$ lua lnrs.lua "oiiiiioiiii"
oi
$ lua lnrs.lua "1234567890"
1234567890
$ lua lnrs.lua "11122324455"
324

주요 아이디어 : 공백으로 모든 것을 인터리브하고 " "긴 식별자를 분할하기 위해 (두 공백) 삽입

Ungolfed 코드 :

g = "gsub"
_G["load"](
   g[g](      -- g[g] == string.gsub - a function for substitution of substrings
      "The source of actual program, but two-space sequences were inserted in some places", 
      "  ",   -- we are replacing all two-space substrings
      ""      -- with an empty string
   )
)(...)

실제 프로그램 (공백을 모두 제거한 후) :

s = ...
for d = #s - 1, 0, -1 do
   for r = 1, #s - d do
      t = s:sub(r, r+d)
      if not t:find"(.).*%1" then
         print(t)
         return
      end
   end
end

BTW, 점수를 계산하기위한 JS 스 니펫이 내 코드에서 실패합니다.

레티 나 0.8.2 , 37 바이트, 9 점

.
$&$'¶
(.)(?<=\1.+).*

O#$^`
$.&
1G`

온라인으로 사용해보십시오! 이 답변을 Retina 1로 직접 변환하면 N대신을 사용하여 바이트가 절약 됩니다 O#. 그러나 레티 나 1이 순식간에 28 바이트로 골프를 치면 점수는 실제로 10으로 올라갑니다! 설명:

.
$&$'¶

입력의 모든 접미사를 생성하십시오.

(.)(?<=\1.+).*

각 접미사에 대해 첫 번째 복제 문자까지 접두사를 사용하십시오.

O#$^`
$.&

나머지 문자열을 길이의 역순으로 정렬하십시오 (즉, 가장 긴 것부터).

1G`

가장 오래 걸리십시오.

젤리 , 2, 14 바이트 점수

Ẇµµff  Q  €  Ṫ

점수 -1, +7 바이트 및 버그 발견에 대한 @JonathanAllan에게 감사합니다.

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

작동 원리

Ẇµµff  Q  €  Ṫ  Main link. Argument: s (string)

Ẇ               Window; yield all substrings of s, sorted by length.
 µ              Begin a new chain. Argument: A (array of substrings)
  µ             Begin a new chain. Argument: A (array of substrings)
   f            Filter A by presence in itself. Does nothing.
       Q  €     Unique each; deduplicate all strings in A.
    f           Filter A by presence in the array of deduplicated substrings,
                keeping only substrings composed of unique characters.
             Ṫ  Tail; take the last (longest) kept substring.

깨끗함 , 점수 7 5, 276 바이트

@[ss:s]=rr(pp[][ss:s])((@s))
@s=s
ee x[rr:xx]|e x rr=True=ee x xx
ee x xx=f
f=e'e'' '
e::!  Char  !  Char  ->Bool
e  _ _=  code  {

eqC
}
pp p[r:rr]|ee r p=p=pp(a r p)rr
pp a _=a
a  x[ll:l]=[ll:a x  l]
a l ll=[l]
l[]rr=e'l''l'
l ff[]=f

l[r:rr][ss:ll]=l rr ll
rr x y|l x y=y=x

온라인으로 사용해보십시오! Clean 내에서 ABC 기계 코드를 직접 호출 할 수 있음을 알려 주신 @ Οurous 에게 감사드립니다 . import최소 점수를 7로 설정했지만 키워드가 필요한 이전 병목 현상을 제거 할 수 있습니다.code 이 방법에서는 최소 점수를 5로 설정하는 가 .

위 코드의 골프가없고 점수가 최적화되지 않은 버전은 여기에서 찾을 수 있습니다. 온라인으로 사용해보십시오!

점수 7 이전 버전, 158 (154) 130 바이트

import  StdEnv  
@[xx:rr]=c(%[][xx:rr])(@rr)
@e=e
c s b|  length  s<  length  b=b=s
%s[xx:r]|  isMember xx s=s= %(s++[xx])r
%r _=r

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

으로 import점수가 어떤 라이브러리 함수없이 문자열이나 문자에 평등을 구현해야합니다 가져 오기 하나없이 7. 아래로 갈 수 없어 아마 위의 새 버전에서 볼 수 있듯이, 수.

파이썬 3 , 점수 4, 155 바이트

exec(('l=la''mbd''a f'',e=en''ume''rat''e:m''ax''([f[ j  :k]  for  j,i in e ( f)f''or  k,i in e ( f )if  len  ( { *''f[j'':k]''})==k-''j],''key''=le''n)'))

이것은 함수를 정의합니다 l.

길이가 3 인 문자열은 점수를 높이 지 않고 32 바이트를 절약한다는 점을 지적 한 @xnor 덕분입니다.

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

Brachylog , 점수 2, 19 바이트

s  ᶠ  l  ᵒ  ≠  ˢ  t

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

지루한 오래된 "모든 것을 밖으로 나눕니다"라는 대답. 적어도 메타 술어가 술어와 떨어져있을 수 있으며 여전히 작동하고 (매개 변수 첨자 및 위 첨자는 할 수 없음) 배웠습니다.

s ᶠ -주어진 문자열의 모든 하위 문자열을 찾습니다

l ᵒ -길이별로 주문 (기본적으로 오름차순)

≠ ˢ -모든 고유 요소를 가진 요소를 선택하십시오

t -그것의 꼬리 (마지막 요소)를 얻습니다-길이가 가장 큰 것

Pyth , 11 바이트, 4 점

Dennis 덕분에 -4 점

e lD {I# .:

elD{I#.:Q      Full program, inputs "string" from stdin and outputs to stdout
e              The last element of the list generated by taking
      .:Q      All substrings of the input
     #         Filtered for
   {I          Being invariant over deduplicate i.e. being "non-repeating"
 lD            and sorted by length

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

껍질 , 점수 2, 10 바이트

►IIËII≠IIQ

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

설명

이 프로그램은 다음과 같습니다.

►Ë≠Q  Implicit input.
   Q  List of substrings.
►     Find one that maximizes:
 Ë    all ordered pairs
  ≠   are inequal.

내장 된 Ë평가하여 ≠인수의 모든 순서쌍에 x, 반환 length(x)+1모든 결과는 그렇지 truthy 경우 0. 이를 최대화하면 반복되는 문자가없는 가장 긴 문자열을 찾습니다.

제출에서는 I각 함수 사이에 ID 함수 를 두 번 삽입합니다 . 이후 IË와 동일 Ë, I≠동일하다 ≠등등,이 의미를 변경하지 않는다. 유일한 위험은 고차 함수가 Is 중 하나를 인수로 사용하기로 결정할 수 있지만 운 좋게도 프로그램에서 유형 오류가 발생하므로 발생하지 않습니다.

클로저, 4 점

#(  let  [N  (fn  [[_ & r]] r) R  (fn  R [f v c]  (if  c (R f (f v (  nth  c 0))  ( N  c)) v)) C  (fn  C  (  [i]  (C (  seq  i) 0)) ( [i  n]  (if i (C ( N  i )  (  inc n)) n)))  J  (fn  [c  i]  (assoc c (C  c) i)) I  (fn  F [f i n R]  (if ( =  (C  R) n) R (F f (f  i) n ( J  R (f  i)))))] ( apply  str  (R ( fn  [a  b] ( if  (< (C  a)  (C  b)) b a )) "" (  for  [k  (I N % (C  % ) [])]  (R  ( fn [ t  c ] ( if ( or ( = t (  str t) ) ((  set t)c))(apply  str t) ( J  t c)))[]k)))))

아 이거 아 ful 어! Nimplements next, Ris reduce, Cis count, Jis conj(벡터에만 적용) 및 Iis iterate입니다. apply str그렇지 않으면 "aaaa"입력이 문자열이 아니라 벡터를 반환하기 때문에 두 번 [\a]있습니다. 운 좋게도 사용 apply하고 assoc벡터의 마지막 요소를 넘어 하나의 인덱스를 할당 할 수 있다는 것을 몰랐습니다.

젤리 , 5, 10 바이트 점수

ẆµQQ⁼µÐfµṪ

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

파이썬 3 , 4, 317 바이트

exec(('%s'  *58  %(  's=','in','pu','t(',');','pr','in','t(','so','rt','ed','((s','[i',':j',']f','or',' j',' i','n ','ra','ng','e(','1,','le','n(','s)','+1',')f','or',' i',' i','n ','ra','ng','e(','j)','if',' l','en','(s','et','(s','[i',':j',']))','==l','en','(s','[i',':j',']))',',k','ey','=l','en',')[','-1','])')))

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

실행되지 않은 코드 :

s=input();print(sorted((s[i:j]for j in range(1,len(s)+1)for i in range(j)if len(set(s[i:j]))==len(s[i:j])),key=len)[-1])

lambda a는 mbda 5 점을 가지고 return있고, execed를 할 수없는 기능이 필요 하기 때문에 (그래서 5 점 이상을 얻음 eturn) 전체 프로그램이 필요했습니다. 실행되지 않은 코드 크기를 약간 줄이려고 할 수는 있지만 빠른 개선을 볼 수는 없습니다.

Alice , 40 바이트

/ii..nn$$@@BBww..DD~~FF..!!nn$$KK??oo@@

(트레일 링 개행)

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

명령 포인터는 순서 모드에서 대각선으로 이동하므로 다른 모든 문자 만 실행됩니다.

i.n$@Bw.D~F.!n$K?o@

i     take input
.n$@  terminate if empty
B     push all nonempty substrings, with the longest on the top of the stack
w     push return address (start main loop)
.     make copy of current substring
D     deduplicate characters
~     swap: this places the original above the deduplicated copy
F     Push the original string if it is a substring of the deduplicated copy
      (which can only happen if they're equal); otherwise push empty string
.!    place a copy on the tape
n$K   if the empty string was pushed, return to start of loop
o     output
@     terminate

Perl 6 , 점수 : 15 10 8, 길이 : 46 55 62 바이트

{~m:ov/(.+)<!{$0.comb.repeated}>/.max(&chars)}

그것을 테스트

{~m:ov/(..*)<!{(($0)).comb.repeated}>{{}}/.max(&chars)}

그것을 테스트

{m:ov:i/(..*)<!{(($0)).comb.repeated}>{{}}/.max((&chars)).Str}

그것을 테스트

넓히는:

{    # bare block lambda with implicit parameter ｢$_｣

    m                          # match (implicitly against ｢$_｣)
    :overlap                   # in every single way possible
    :ignorecase                # add a ｢:｣ to break up substring
    /

      (..*)                    # match at least one character

      <!{
        (($0)).comb.repeated  # backtrack if there were repeats
      }>

      {{}}                    # anon hash in code block (no-op)
    /

    .max((&chars))            # get the longest

    .Str                      # coerce to a Str (from a Match object)
}

Java 8, 점수 9 (384B) 7 (401B)

S -> { int s = 0 , e = 0 , l = 0 , x = 0 , y = 0 , b [ ] = new int [ 256 ] ; for ( ; x <S.  length  & y <S.  length  & l <S.  length  - x ; x ++ ) { b [S[x]] = 1 ; for ( y ++ ; y <S.  length  && b [S[y]] < 1 ; b [S[y ++]] = 1 ) ; if ( l < y - x ) { s = x ; e = y ; l = y - x ; } for ( ; y <S.  length  && x < y & S[x] != S[y  ];)b [S[x ++]] = 0 ; }  String g=""; for( ; s<e ; g+= S[s++]);  return  g;}

• 초기 버전. 여기에서 내려갑니다. 로 인해 점수는 9 점 "ubstring "이므로 substring교체 할 첫 번째 부분이됩니다.
• 으로 인해 점수가 7 점으로 " length", 아마도 더 이상 줄어들 수 없을 것입니다 length. 의 네 가지 용도를 버릴 수 있을지 의심됩니다 . 가능하다면 " eturn"(6) 최종 개선으로 점수를 1 씩 낮출 수는 있지만 바이트 수의 작은 감소는 제외합니다.

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

하스켈 , 7 점

Laikoni 덕분에 -4.

import  Data.List  
f s=snd $ maximum [ (0<$i ,i)|i<-  tails  =<<inits s, nub i==i]

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

매스 매 티카는, 득점 (11) (9)

Length@Last@Select[Subsequences[Characters@#],#==DeleteDuplicates  @#&]&

함수 이름을 가려서 반복되지 않는 가장 긴 문자열에서 몇 바이트를 제거합니다.

Length@Last@Select[Subsequences[Characters  @#],#==(  ToExpression@ 
StringJoin@@FromCharacterCode@{{68},{101},{108},{101},{116},{101},{68},{117},
{112},{108},{105},{99},{97},{116},{101},{115}}))@#&]&

코 틀린은 , 점수 : 11 10 9 바이트, 길이 : 227 246 245 바이트

indices
  .flatMap { p -> indices . map { p to p + it } }
  .  filter { (r,i) -> i < length  }
  .map { ( s , a )->substring  (  s,  a  ) }
  .  filter { it  .  groupBy  { it } .  none { ( k , v )->v . size>1 } }
  .maxBy { it.length }

가장 긴 ubstring 문자는 9 자입니다.

다음과 같이 호출됩니다.

val c = "Good morning, Green orb!"

fun String.c(): String? = indices
    .flatMap { p -> indices . map { p to p + it } }
    .  filter { (r,i) -> i < length  }
    .map { ( s , a )->substring  (  s,  a  ) }
    .  filter { it  .  groupBy  { it } .  none { ( k , v )->v . size>1 } }
    .maxBy { it.length }

fun main(args: Array<String>) {
    val text = """indices
    .flatMap { p -> indices . map { p to p + it } }
    .  filter { (r,i) -> i < length  }
    .map { ( s , a )->substring  (  s,  a  ) }
    .  filter { it  .  groupBy  { it } .  none { ( k , v )->v . size>1 } }
    .maxBy { it.length }"""
    val message = text.c()!!
    println(message)
    println(text.length)
    println(message.length)
    println(c.c())
}

Pyth , 3 점 (  18  14 바이트)

e  fq  T{T  .:

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

반복되지 않는 가장 긴 부분 문자열은  .:입니다.

05AB1E , 22 바이트 | 점수 : 2

Œ  ʒ  D  Ù  Q  }  é  ¤

HeebyJeeby 덕분에 -1 점수 + 7 바이트

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

05AB1E , 15 바이트 | 점수 : 3

Œ ʒ D Ù Q } é ¤

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

05AB1E , 8 바이트 | 점수 : 8

ŒʒDÙQ}é¤

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

05AB1E는 실제로 다소 저렴한 작업을 수행 할 수 있습니다. 05AB1E에 공백을 추가하면 아무 효과가 없습니다.

이것에 대한 규칙이 있다면, 나는 또한 ´7 개의 다른 문자를 사용할 수 있습니다 .