주요 요인 친구


21

정수가 주어지면 N > 1소수 분해가 소수 분해와 같은 자릿수를 갖는 다른 모든 숫자를 출력하십시오 N.

예를 들어이면 N = 117출력은이어야합니다 [279, 939, 993, 3313, 3331].

117 = 3 × 3 × 13

따라서 가능한 숫자는 1, 3, 3그리고 3우리는이

279  = 3 × 3 × 31
939  = 3 × 313
993  = 3 × 331
3313 = 3313
3331 = 3331

이 숫자의 다른 조합은 소수 이외의 정수를 생성하므로 소수 분해의 결과가 될 수 없으므로 가능한 다른 숫자입니다.

경우 N중 하나입니다 117, 279, 939, 993, 3313또는 3331, 출력이 다섯 개 개의 다른 숫자가 포함됩니다 : 그들은 소인수 친구됩니다.

소수를 얻기 위해 선행 0을 사용할 수 없습니다. 예를 들어 N = 107, 유일한 친구는 701( 017고려되지 않음)입니다.

입력 및 출력

  • 입력 및 출력 친구는 10 진수로 가져 와서 반환해야합니다.

  • N항상보다 큽니다 1.

  • 버디 및 구분 기호 / 목록 구문 요소 만 포함하는 한 출력을보다 자유롭게 형식화 할 수 있습니다.

  • 출력 순서는 중요하지 않습니다.

  • 를 통해 입력을 STDIN함수 인수 또는 이와 유사한 것으로 사용할 수 있습니다.

  • 출력을로 인쇄 STDOUT하거나 함수 또는 이와 유사한 것에서 반환 할 수 있습니다 .

테스트 사례

프로그램은 1 분 이내에 아래의 테스트 사례를 해결해야합니다 .

N        Buddies
2        []
4        []
8        []
15       [53]
16       []
23       [6]
42       [74, 146, 161]
126      [222, 438, 483, 674, 746, 851, 1466, 1631, 1679]
204      [364,548,692,762,782,852,868,1268,1626,2474,2654,2921,2951,3266,3446,3791,4274,4742,5426,5462,6233,6434,6542,7037,8561,14426,14642,15491,15833,22547]

채점

이것은 이므로 바이트 단위의 최단 답변이 이깁니다.

답변:


4

젤리 , 14 바이트

ÆfVṢṚḌ
ÇÇ€=ÇTḟ

실행 시간은 DF대신에 절반으로 줄어들 수 V있지만 여전히 30 초 이내에 결합 된 테스트 사례를 완료합니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

ÆfVṢṚḌ   Helper link. Argument: k (integer)

Æf       Decompose k into an array of primes with product k.
  V      Eval. Eval casts a 1D array to string first, so this computes the integer
         that results of concatenating all primes in the factorization.
   Ṣ     Sort. Sort casts a number to the array of its decimal digits.
    Ṛ    Reverse. This yields the decimal digits in descending order.
     Ḍ   Undecimal; convert the digit array from base 10 to integer.


ÇÇ€=ÇTḟ  Main link. Argument: n (integer)

Ç        Call the helper link with argument n.
         This yields an upper bound (u) for all prime factorization buddies since
         the product of a list of integers cannot exceed the concatenated integers.
 ǀ      Apply the helper link to each k in [1, ..., u].
    Ç    Call the helper link (again) with argument n.
   =     Compare each result to the left with the result to the right.
     T   Truth; yield all 1-based indices of elements of [1, ..., u] (which match
         the corresponding integers) for which = returned 1.
      ḟ  Filter; remove n from the indices.

시간 제약을 감안할 Ç€=$때보 다 약간 빠를 것이라고 생각합니다 Ç€=Ç.
Outgolfer Erik

고맙지 만 입력 117의 경우 개선 사항은 도우미 링크가 3332 번이 아닌 3331 번 호출되므로 속도 향상을 측정 할 수 없습니다. 어쨌든, 최신 (더 빠른) TIO는 결합 된 테스트 사례에 20 초가 필요하지 않습니다 .
Dennis

16

PowerShell v3 +, 450 바이트

param($n)function f{param($a)for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}}}
$y=($x=@((f $n)-split'(.)'-ne''|sort))|?{$_-eq(f $_)}
$a,$b=$x
$a=,$a
while($b){$z,$b=$b;$a=$a+($a+$y|%{$c="$_";0..$c.Length|%{-join($c[0..$_]+$z+$c[++$_..$c.Length])};"$z$c";"$c$z"})|select -u}
$x=-join($x|sort -des)
$l=@();$a|?{$_-eq(f $_)}|%{$j=$_;for($i=0;$i-le$x;$i+=$j){if(0-notin($l|%{$i%$_})){if(-join((f $i)-split'(.)'|sort -des)-eq$x){$i}}}$l+=$j}|?{$_-ne$n}

마침내!

PowerShell에는 우선 순위 검사, 인수 분해 또는 순열을위한 기본 제공 기능이 없으므로 수동으로 완전하게 롤업됩니다. 나는 시간 제한을 도전 과제 제한에 맞는 것으로 줄이기 위해 많은 최적화 트릭을 연구했으며 마침내 성공했다고 말하게되어 기쁘다.

PS C:\Tools\Scripts\golfing> Measure-Command {.\prime-factors-buddies.ps1 204}

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 27
Milliseconds      : 114
Ticks             : 271149810
TotalDays         : 0.000313830798611111
TotalHours        : 0.00753193916666667
TotalMinutes      : 0.45191635
TotalSeconds      : 27.114981
TotalMilliseconds : 27114.981

설명

여기에는 많은 일이 있기 때문에 그것을 분해하려고 노력할 것입니다.

첫번째 라인 입력 얻어 $n및 정의를 function, f. 이 기능은 누적 시험 분할을 사용하여 주요 요인 목록을 표시합니다. 작은 입력의 경우 속도가 빠르지 만 입력이 큰 경우 분명히 줄어 듭니다. 고맙게도 모든 테스트 사례는 작기 때문에 이것으로 충분합니다.

다음 줄은 도착 f의 배우 $n, -split(이 PowerShell을 정규식 일치하지하고 입력을 통해 포인터를 이동하고 목적을 골프에 대한 좀 짜증나는 어떻게하는 방법으로 인해 필요) 빈 결과를 무시하고 모든 자리에 그들을이야, 다음 sort결과를이야 오름차순으로. 우리는 그 숫자 배열을에 저장하고 그 자체를 소수 인 것을 꺼내기 $x위해 |?{...}필터 의 입력으로 사용합니다 . 이 소수는 $y나중에 사용하기 위해 저장됩니다 .

그런 다음 $x두 가지 구성 요소 로 나눕니다 . 첫 번째 (즉, 가장 작은) 숫자는에 저장되고 $a나머지는에 전달됩니다 $b. $x하나의 숫자 만있는 경우 $b비어 있거나 널이됩니다. 그런 다음 $a배열로 다시 캐스팅해야 하므로 쉼표 연산자를 사용하여 신속하게 수행 할 수 있습니다.

다음으로 가능한 모든 숫자 순열을 구성해야합니다. 이것은 우리의 분할 테스트가 나중에 많은 수 를 건너 뛰고 전반적인 속도를 높이기 위해 필요합니다.

에 요소가 남아있는 $b한 첫 번째 자리를 벗기고 $z나머지는에 남겨 둡니다 $b. 그런 다음 $a문자열 슬라이싱 및 다이 싱 결과에 누적해야합니다 . 우리는 가지고 $a+$y배열 연결로, 각 요소에 대해 우리는 새로운 캐릭터 구축 $c을 통해 다음 루프 $c.length및 삽입을 $z붙이는 포함하여 모든 위치로 $z$c하고 추가 $c$z, 다음 select만을 보내고 -unique 요소를. 다시 배열로 연결 $a되고에 다시 복원됩니다 $a. 예, 3333입력 할 수있는 것처럼 구피가 발생하면 문제가 해결 됩니다.117실제로 순열은 아니지만 명시 적으로 필터링하려고 시도하는 것보다 훨씬 짧으며 모든 순열을 얻도록 보장하며 속도가 매우 느립니다.

따라서 이제 $a요인의 자릿수에 대한 모든 가능한 (그리고 일부) 순열이 배열됩니다. 우리 는 자릿수를 오름차순으로 정렬하고 다시 함께 $x연결하여 가능한 결과의 상한 이되도록 재설정해야 합니다. 분명히이 값보다 큰 출력 값은 없습니다.|sort-des-join

헬퍼 배열 $l을 이전에 본 값의 배열로 설정했습니다. 다음으로, 우리 $a는 소수 인 모든 값 (즉, 순열)을 끌어 내고 전체 프로그램에서 가장 큰 타임 싱크 인 루프에 들어갑니다 ...

모든 반복마다 현재 요소에 따라 증가하여 0상한으로 반복됩니다 . 우리가 고려 하고있는 가치가 이전 가치 (이 부분) 의 배수 가 아닌 한 , 그것은 산출의 잠재적 후보입니다. 우리가 가지고가는 경우 의 배우 , 그들, 그들은 연간 , 다음 파이프 라인에 값을 추가합니다. 루프가 끝나면 모든 값을 이미 고려 했으므로 다음에 사용할 현재 요소 를 배열에 추가 합니다.$x$j$i0-notin($l|%{$i%$_})f$isort-eq$x$j$l

마지막으로 |?{$_-ne$n}입력 요소가 아닌 것을 꺼내기 위해 노력합니다. 그것들은 모두 파이프 라인에 남아 있으며 출력은 암시 적입니다.

PS C:\Tools\Scripts\golfing> 2,4,8,15,16,23,42,117,126,204|%{"$_ --> "+(.\prime-factors-buddies $_)}
2 --> 
4 --> 
8 --> 
15 --> 53
16 --> 
23 --> 6
42 --> 74 146 161
117 --> 279 939 993 3313 3331
126 --> 222 438 674 746 1466 483 851 1679 1631
204 --> 782 2921 3266 6233 3791 15833 2951 7037 364 868 8561 15491 22547 852 762 1626 692 548 1268 2654 3446 2474 5462 4742 5426 4274 14426 6542 6434 14642

그것은 내가 본 것 중 가장 많은 달러입니다!
Fatalize

1
@Fatalize 450 개 중 64 개에 불과합니다. 이는 놀랍게도 PowerShell 답변의 경우 낮은 비율 (14.22 %)입니다.
AdmBorkBork

8

CJam , 26 23 바이트

{_mfs$:XW%i){mfs$X=},^}

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

설명

두 숫자를 연결하면 항상 곱하는 것보다 더 큰 결과가 나타납니다. 따라서 고려할 필요가있는 가장 큰 숫자는 입력의 소인수 분해의 숫자에서 형성 할 수있는 가장 큰 숫자이며, 모든 숫자는 내림차순으로 정렬됩니다. 주어진 숫자에 대해이 상한은 쉽게 작아서 범위의 모든 숫자가 주요 요인 친구인지 여부를 철저히 확인할 수 있습니다.

_mf    e# Duplicate input N and get a list of its prime factors.
s$     e# Convert the list to a (flattened) string and sort it.
:X     e# Store this in X for later.
W%     e# Reverse it. This is now a string repesentation of the largest 
       e# possible output M.
i)     e# Convert to integer and increment.
{      e# Get a list of all integers i in [0 1 ... M] for which the following
       e# block gives a truthy result.
  mf   e#   Get list of prime factors of i.
  s$   e#   Get a sorted list of the digits appearing in the factorisation.
  X=   e#   Check for equality with X.
},
^      e# Symmetric set difference: removes N from the output list.

6

05AB1E , 17 바이트

암호:

ÒJ{©RƒNÒJ{®QN¹Ê*–

설명:

Ò                  # Get the factorization with duplicates, e.g. [3, 3, 13]
 J                 # Join the array, e.g. 3313
  {©               # Sort and store in ©, e.g. 1333
    R              # Reverse the number, e.g. 3331. This is the upperbound for the range
     ƒ             # For N in range(0, a + 1), do...
      NÒ           # Push the factorization with duplicates for N
        J          # Join the array
         {         # Sort the string
          ®Q       # Check if equal to the string saved in ©
            N¹Ê    # Check if not equal to the input
               *   # Multiply, acts as a logical AND
                –  # If 1, print N

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!


4

피 이스, 17

LSjkPb-fqyTyQSs_y

테스트 스위트 .

Martin의 게시물 과 동일한 관찰을 사용합니다 .

확장:

LSjkPb        ##  Define a function y(b) to get the sorted string of digits
              ##  of the prime factors of b
    Pb        ##  prime factors
  jk          ##  join to a string with no separator
 S            ##  Sort

-fqyTyQSs_yQQ ##  Auto-fill variables
         _yQ  ##  get reversed value of y(input)
       Ss     ##  convert that string to a list [1 ... y(input)]
 fqyTyQ       ##  keep numbers T from the list that satisfy y(T)==y(input)
-           Q ##  remove the input from the result

3

자바 스크립트 (ES6) 163 158 바이트

편집 : 23과 같은 소수는 빈 결과 집합보다 [6]을 반환해야 함이 명확 해졌습니다. 현재 쓸모없는 규칙을 의도적으로 제거하여 5 바이트를 절약했습니다.

마지막 테스트 사례는이 스 니펫이 1 분 이내에 완료되어야하지만 충분히 빠르게 실행되도록 주석 처리됩니다.

let f =

n=>[...Array(+(l=(p=n=>{for(i=2,m=n,s='';i<=m;n%i?i++:(s+=i,n/=i));return s.split``.sort().reverse().join``})(n))+1)].map((_,i)=>i).filter(i=>i&&i-n&&p(i)==l)

console.log(JSON.stringify(f(2)));
console.log(JSON.stringify(f(4)));
console.log(JSON.stringify(f(8)));
console.log(JSON.stringify(f(15)));
console.log(JSON.stringify(f(16)));
console.log(JSON.stringify(f(23)));
console.log(JSON.stringify(f(42)));
console.log(JSON.stringify(f(126)));
//console.log(JSON.stringify(f(204)));


1

PHP 486 바이트

아마도 책에서 그렇지 않은 알고리즘으로 더 짧을 수도 있습니다.
(그러나 나는 현재 바이트 수를 좋아한다)

function p($n){for($i=1;$i++<$n;)if($n%$i<1&&($n-$i?p($i)==$i:!$r))for($x=$n;$x%$i<1;$x/=$i)$r.=$i;return $r;}function e($s){if(!$n=strlen($s))yield$s;else foreach(e(substr($s,1))as$p)for($i=$n;$i--;)yield substr($p,0,$i).$s[0].substr($p,$i);}foreach(e(p($n=$argv[1]))as$p)for($m=1<<strlen($p)-1;$m--;){$q="";foreach(str_split($p)as$i=>$c)$q.=$c.($m>>$i&1?"*":"");foreach(split("\*",$q)as$x)if(0===strpos($x,48)|p($x)!=$x)continue 2;eval("\$r[$q]=$q;");}unset($r[$n]);echo join(",",$r);

고장

// find and concatenate prime factors
function p($n)
{
    for($i=1;$i++<$n;)  // loop $i from 2 to $n
        if($n%$i<1      // if $n/$i has no remainder
            &&($n-$i    // and ...
                ?p($i)==$i  // $n!=$i: $i is a prime
                :!$r        // $n==$i: result so far is empty ($n is prime)
            )
        )
            for($x=$n;      // set $x to $n
                $x%$i<1;    // while $x/$i has no remainder
                $x/=$i)     // 2. divide $x by $i
                $r.=$i;     // 1. append $i to result
    return $r;
}

// create all permutations of digits
function e($s)
{
    if(!$n=strlen($s))yield$s;else  // if $s is empty, yield it, else:
    foreach(e(substr($s,1))as$p)    // for all permutations of the number w/o first digit
        for($i=$n;$i--;)            // run $i through all positions around the other digits
            // insert removed digit at that position and yield
            yield substr($p,0,$i).$s[0].substr($p,$i);
}

// for each permutation
foreach(e(p($n=$argv[1]))as$p)
    // create all products from these digits: binary loop through between the digits
    for($m=1<<strlen($p)-1;$m--;)
    {
        // and insert "*" for set bits
        $q="";
        foreach(str_split($p)as$i=>$c)$q.=$c.($m>>$i&1?"*":"");
        // test all numbers in the expression
        foreach(split("\*",$q)as$x)
            if(
                0===strpos($x,48)   // if number has a leading zero
                |p($x)!=$x          // or is not prime
            )continue 2; // try next $m
        // evaluate expression and add to results (use key to avoid array_unique)
        eval("\$r[$q]=$q;");
    }

// remove input from results
unset($r[$n]);

// output
#sort($r);
echo join(",",$r);

1

실제로 27 바이트

이것은 Martin , Adnan , FryAmTheEggman , Dennis 와 같은 알고리즘을 사용합니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

`w"i$n"£MΣSR≈`╗╜ƒ;╝R`╜ƒ╛=`░

언 골핑

          Implicit input n.
`...`╗    Define a function and store it in register 0. Call the function f(x).
  w         Get the prime factorization of x.
  "..."£M   Begin another function and map over the [prime, exponent] lists of w.
    i         Flatten the list. Stack: prime, exponent.
    $n        Push str(prime) to the stack, exponent times.
               The purpose of this function is to get w's prime factors to multiplicity.
  Σ         sum() the result of the map.
             On a list of strings, this has the same effect as "".join()
  SR≈       Sort that string, reverse it and convert to int.
╜ƒ        Now push the function stored in register 0 and call it immediately.
           This gives the upper bound for any possible prime factor buddy.
;╝        Duplicate this upper bound and save a copy to register 1.
R         Push the range [0..u]
`...`░    Filter the range for values where the following function returns a truthy.
           Variable k.
  ╜ƒ        Push the function in register 0 and call it on k.
  ╛=        Check if f(k) == f(n).
          Implicit return every value that is a prime factor buddy with n, including n.

1

Powershell, 147 바이트 (CodeGolf 버전)

param($n)filter d{-join($(for($i=2;$_-ge$i*$i){if($_%$i){$i++}else{"$i"
$_/=$i}}if($_-1){"$_"})|% t*y|sort -d)}2..($s=$n|d)|?{$_-$n-and$s-eq($_|d)}

참고 :이 스크립트는 로컬 노트북에서 3 분 미만의 마지막 테스트 사례를 해결합니다. 아래의 "성능"솔루션을 참조하십시오.

덜 골프 테스트 스크립트 :

$g = {

param($n)
filter d{                       # in the filter, Powershell automatically declares the parameter as $_
    -join($(                    # this function returns a string with all digits of all prime divisors in descending order
        for($i=2;$_-ge$i*$i){   # find all prime divisors
            if($_%$i){
                $i++
            }else{
                "$i"            # push a divisor to a pipe as a string
                $_/=$i
            }
        }
        if($_-1){
            "$_"                # push a last divisor to pipe if it is not 1
        }
    )|% t*y|sort -d)            # t*y is a shortcut to toCharArray method. It's very slow.
}
2..($s=$n|d)|?{                 # for each number from 2 to number with all digits of all prime divisors in descending order
    $_-$n-and$s-eq($_|d)        # leave only those who have the 'all digits of all prime divisors in descending order' are the same
}

}

@(
    ,(2   ,'')
    ,(4   ,'')
    ,(6   ,23)
    ,(8   ,'')
    ,(15  ,53)
    ,(16  ,'')
    ,(23  ,6)
    ,(42  ,74, 146, 161)
    ,(107 ,701)
    ,(117 ,279, 939, 993, 3313, 3331)
    ,(126 ,222, 438, 483, 674, 746, 851, 1466, 1631, 1679)
    ,(204 ,364,548,692,762,782,852,868,1268,1626,2474,2654,2921,2951,3266,3446,3791,4274,4742,5426,5462,6233,6434,6542,7037,8561,14426,14642,15491,15833,22547)
) | % {
    $n,$expected = $_

    $sw = Measure-Command {
        $result = &$g $n
    }

    $equals=$false-notin(($result|%{$_-in$expected})+($expected|?{$_-is[int]}|%{$_-in$result}))
    "$sw : $equals : $n ---> $result"
}

산출:

00:00:00.0346911 : True : 2 --->
00:00:00.0662627 : True : 4 --->
00:00:00.1164648 : True : 6 ---> 23
00:00:00.6376735 : True : 8 --->
00:00:00.1591527 : True : 15 ---> 53
00:00:03.8886378 : True : 16 --->
00:00:00.0441986 : True : 23 ---> 6
00:00:01.1316642 : True : 42 ---> 74 146 161
00:00:01.0393848 : True : 107 ---> 701
00:00:05.2977238 : True : 117 ---> 279 939 993 3313 3331
00:00:12.1244363 : True : 126 ---> 222 438 483 674 746 851 1466 1631 1679
00:02:50.1292786 : True : 204 ---> 364 548 692 762 782 852 868 1268 1626 2474 2654 2921 2951 3266 3446 3791 4274 4742 5426 5462 6233 6434 6542 7037 8561 14426 14642 15491 15833 22547

Powershell, 215 바이트 ( "성능"버전)

param($n)$p=@{}
filter d{$k=$_*($_-le3e3)
($p.$k=-join($(for($i=2;!$p.$_-and$_-ge$i*$i){if($_%$i){$i++}else{"$i"
$_/=$i}}if($_-1){($p.$_,"$_")[!$p.$_]})-split'(.)'-ne''|sort -d))}2..($s=$n|d)|?{$_-$n-and$s-eq($_|d)}

참고 : 성능 요구 사항이 GodeGolf 원칙과 충돌한다고 생각합니다. 그러나 규칙이 있었기 때문에 규칙 Your program should solve any of the test cases below in less than a minute을 만족시키기 위해 두 가지 변경을 수행했습니다.

  • -split'(.)'-ne''대신 짧은 코드 |% t*y;
  • 캐싱 문자열을위한 해시 테이블

각 변경은 평가 시간을 절반으로 줄입니다. 모든 기능을 사용하여 성능을 개선했다고 생각하지 마십시오. 그것들은 규칙을 만족시키기에 충분했습니다.

덜 골프 테스트 스크립트 :

$g = {

param($n)
$p=@{}                          # hashtable for 'all digits of all prime divisors in descending order'
filter d{                       # this function returns a string with all digits of all prime divisors in descending order
    $k=$_*($_-le3e3)            # hashtable key: a large hashtable is not effective, therefore a key for numbers great then 3000 is 0
                                # and string '-le3e3' funny
    ($p.$k=-join($(             # store the value to hashtable
        for($i=2;!$p.$_-and$_-ge$i*$i){
            if($_%$i){$i++}else{"$i";$_/=$i}
        }
        if($_-1){
            ($p.$_,"$_")[!$p.$_] # get a string with 'all digits of all prime divisors in descending order' from hashtable if it found
        }
    )-split'(.)'-ne''|sort -d)) # split each digit. The "-split'(.)-ne''" code is faster then '|% t*y' but longer.
}
2..($s=$n|d)|?{                 # for each number from 2 to number with all digits of all prime divisors in descending order
    $_-$n-and$s-eq($_|d)        # leave only those who have the 'all digits of all prime divisors in descending order' are the same
}

}

@(
    ,(2   ,'')
    ,(4   ,'')
    ,(6   ,23)
    ,(8   ,'')
    ,(15  ,53)
    ,(16  ,'')
    ,(23  ,6)
    ,(42  ,74, 146, 161)
    ,(107 ,701)
    ,(117 ,279, 939, 993, 3313, 3331)
    ,(126 ,222, 438, 483, 674, 746, 851, 1466, 1631, 1679)
    ,(204 ,364,548,692,762,782,852,868,1268,1626,2474,2654,2921,2951,3266,3446,3791,4274,4742,5426,5462,6233,6434,6542,7037,8561,14426,14642,15491,15833,22547)
) | % {
    $n,$expected = $_

    $sw = Measure-Command {
        $result = &$g $n
    }

    $equals=$false-notin(($result|%{$_-in$expected})+($expected|?{$_-is[int]}|%{$_-in$result}))
    "$sw : $equals : $n ---> $result"
}

산출:

00:00:00.0183237 : True : 2 --->
00:00:00.0058198 : True : 4 --->
00:00:00.0181185 : True : 6 ---> 23
00:00:00.4389282 : True : 8 --->
00:00:00.0132624 : True : 15 ---> 53
00:00:04.4952714 : True : 16 --->
00:00:00.0128230 : True : 23 ---> 6
00:00:01.4112716 : True : 42 ---> 74 146 161
00:00:01.3676701 : True : 107 ---> 701
00:00:07.1192912 : True : 117 ---> 279 939 993 3313 3331
00:00:07.6578543 : True : 126 ---> 222 438 483 674 746 851 1466 1631 1679
00:00:50.5501853 : True : 204 ---> 364 548 692 762 782 852 868 1268 1626 2474 2654 2921 2951 3266 3446 3791 4274 4742 5426 5462 6233 6434 6542 7037 8561 14426 14642 15491 15833 22547

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.