私はあなたのために十分ではありませんか?


29

バックグラウンド:

現在のPerfect Numbersの課題は、数の要因を含む複雑な形式で出力するように求められるため、かなり欠陥があり複雑です。これは、チャレンジの純粋な再投稿です。

チャレンジ

任意の標準入力形式で正の整数を指定すると、それが完全かどうかを区別します。

完全数とは、すべての適切な除数の合計に等しい数です(正の除数はそれ自体よりも小さい)。例えば、その約数であるため、完全数であるに合計、ながら、その約数(以来、完全数でない)までの合計、ではありません。6123612123461612

テストケース:

Imperfect:
1,12,13,18,20,1000,33550335

Perfect:
6,28,496,8128,33550336,8589869056

ルール

  • メモリや時間の制約がある場合、プログラムはより大きなテストケースを完了する必要はありませんが、より多くのメモリ/時間を与えられれば理論的にはできるはずです。
  • 出力は、許可された出力形式を使用して、2つの異なる一貫した値にすることができます。Perfect / Imperfectを表すものがすぐに分からない場合は、回答で必ず指定してください。

待って、真実は完全ではない値のためであり、偽はそうである値のためですか?
エソランジングフルーツ

2
@ Tvde1適切な除数は数値より小さくなければなりません。そうでなければ1、すべての数値は1それ自体で割り切れるので、完全な除数以外の数値はありません。の適切な除数の合計は次のとおり1です0
ジョーキング

3
@Grimy 証明できる場合のみ。がんばろう!(私はそれがどのようにバイトを節約するのだろうかと思っていますが)
ジョー・キング

1
いえ、残念です。それは約3倍にECMAの正規表現の答えのサイズを削減する
Grimmy

3
「出力は2つの異なる一貫した値にすることができます」-ここで「真偽対偽」を使用しないでください(たとえば、ゼロ対ゼロ以外を使用するPython、コンテンツ付きリストと空リスト、およびそれらの組み合わせ)。
ジョナサンアラン

回答:



9

ニーム、3バイト

𝐕𝐬𝔼

オンラインでお試しください!

(実際には、15分ほど前にNeimを学習し始めて以来、すべてのテストケースを一度に実行する方法はわかりませんが、個別にチェックしました。)

不完全な場合は0、完全な場合は1を印刷します。

𝐕      Pop an int from the stack and push its proper divisors,
       implicitly reading the int from a line of input as the otherwise absent top of the stack.
 𝐬     Pop a list from the stack and push the sum of the values it contains.
  𝔼    Pop two ints from the stack and push 1 if they are equal, 0 if they are not;
       implicitly reading the same line of input that was already read as the second int, I guess?
       Implicitly print the contents of the stack, or something like that.

2
私は推測しますか?」; 「またはそのようなもの」。自分が何を書いたのかわからないときは、ハハ。;)しかし、はい、それは実際にどのように機能するかです。私はNeimを知りませんが、そのような入力を暗黙的に使用し、最後に暗黙的に出力することは05AB1Eでも同様です。
ケビンクルーッセン

𝔼1バイトはどうですか?Neimはこのような非スタンダートキャラクターを128個しか使用しませんか?
13:39のkajacx

3
@kajacx Neimには独自のコードページがあります。したがって、コードページに存在する256文字のそれぞれは、1バイトを使用してエンコードできます。
Xcoder

8

R33 29バイト

!2*(n=scan())-(x=1:n)%*%!n%%x

オンラインでお試しください!

TRUE完全な数値とFALSE不完全な数値を返します。


行の2!sは何をもたらしますか?
CTホール

@CTHall仕様を読み違えました。それらは元々0(完全)にマッピングされFALSE、ゼロ以外にマッピングされてTRUEいましたが、マッピングを逆にするためにそのうちの1つを削除しました。それはからのキャストに便利なゴルフのトリックだnumericlogical、多くの場合と一緒に、whichまたは[
ジュゼッペ



6

Python 3、46バイト

lambda x:sum(i for i in range(1,x)if x%i<1)==x

オンラインでお試しください!

総当たりで、因子を合計し、等しいかどうかをチェックします。


2
内包条件を反復変数のマスクとして使用すると、1バイト節約できます。
ジョナサンフレッチ

あなたは不完全な数の真実を返すことができるのでlambda x:sum(i for i in range(1,x)if x%i<1)^x、同様に動作するはずです。
nedla2004

5

Python、45バイト

lambda n:sum(d*(n%d<1)for d in range(1,n))==n

True完璧に False他の人のために(==->でこれを切り替える!=

オンラインでお試しください!

「truthy vs falsey」を使用して出力できる場合、  44 42  41バイト(ovsのおかげで-2):

f=lambda n,i=1:i/n or-~f(n,i+1)-(n%i<1)*i

(falsey(0))完璧な場合; それ以外の場合、真理値(ゼロ以外の整数)


2番目の出力形式が有効な場合、これは42バイトで実行できます
ovs

@ovsああ、うまくできました。
ジョナサンアラン

@ovs ..そしてそれから保存された別の-ありがとう!
ジョナサンアラン

5

オクターブ、25バイト

@(n)~mod(n,t=1:n)*t'==2*n

オンラインでお試しください!

説明

@(n)~mod(n,t=1:n)*t'==2*n

@(n)                        % Define anonymous function with input n
             1:n            % Row vector [1,2,...,n]
           t=               % Store in variable t
     mod(n,     )           % n modulo [1,2,...,n], element-wise. Gives 0 for divisors
    ~                       % Logical negate. Gives 1 for divisors
                  t'        % t transposed. Gives column vector [1;2;...;n]
                 *          % Matrix multiply
                      2*n   % Input times 2
                    ==      % Equal? This is the output value

4

JavaScript、38バイト

n=>eval("for(i=s=n;i--;)n%i||!(s-=i)")

オンラインでお試しください!

(TIOの最後のテストケースタイムアウト。)


@Arnauld f=再帰関数からの変換後を削除するのを忘れていました。
tsh

好奇心から、再帰バージョンを使用してみませんか?(34バイトになります。)
Arnauld

@Arnauldは、スタックオーバーフローが原因で、より大きなテストケースでは再帰バージョンが単に失敗するためです。動作させるには、デフォルトで厳格モードに設定されている環境が必要な場合があります。
tsh

2
十分ですが、プログラムはより大きなテストケースを完了する必要はありません(とにかくデフォルトのルールだと思います)。
アーナルド

4

C#(Visual C#Interactive Compiler)、46バイト

n=>Enumerable.Range(1,n).Sum(x=>n%x<1?x:0)^n*2

完全な場合は0を返し、そうでない場合は正の数を返します。2つの異なる真理値と偽値の代わりに異なるタイプの整数の出力が許可されているかどうかはわかりませんが、メタに関する議論は見つかりませんでした。これが無効な場合、削除します。

オンラインでお試しください!

C#(Visual C#Interactive Compiler)49 47バイト

n=>Enumerable.Range(1,n).Sum(x=>n%x<1?x:0)==n*2

オンラインでお試しください!



3

TI-BASIC(TI-84)、30 23バイト

:2Ans=sum(seq(Ans/Xnot(remainder(Ans,X)),X,1,Ans,1

ひどく非効率ですが、動作します。
バイト数を減らすと、プログラムが大幅に高速化されました。
入力はですAns
出力は入力Ansされ、プログラムが完了すると自動的に印刷されます。

説明:
(TI-BASICにはコメントがありませんので;、コメントを作成すると仮定してください)

:2Ans=sum(seq(Ans/Xnot(remainder(Ans,X)),X,1,Ans    ;Full program

 2Ans                                               ;double the input
          seq(                                      ;generate a list
                                         X,          ;using the variable X,
                                           1,        ;starting at 1,
                                             Ans     ;and ending at the input
                                                     ;with an implied increment of 1
              Ans/X                                 ;from the input divided by X
                   not(                ),           ;multiplied by the negated result of
                       remainder(Ans,X)              ;the input modulo X
                                                     ;(result: 0 or 1)
      sum(                                          ;sum up the elements in the list
     =                                              ;equal?

例:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

注: プログラムのバイトカウントは、[MEM] > [2] > [7]の値(36バイト)を使用して評価され、プログラムの名前の長さCDGF2、(5バイト)および余分な8バイトが使用されますプログラムの保存:

36-5-8 = 23バイト


3

Java(JDK)、54バイト

n->{int s=0,d=0;for(;++d<n;)s+=n%d<1?d:0;return s==n;}

オンラインでお試しください!

厳密な数値ごとのマッチングの場合、次は同じ値を返しますが、40バイトのみです。

n->n==6|n==28|n==496|n==8128|n==33550336

オンラインでお試しください!


ルールによるとYour program doesn't have to complete the larger test cases, if there's memory or time constraints, but it should be theoretically able to if it were given more memory/time.
ジョーキング

@JoKingこれは、Java intをまったく使用できないという意味BigIntegerですか?JavaにはBigIntegersがありますが、int符号付きとして31ビットを超えることはないため、ここに示されている値以外の値を保持することはできません...
OlivierGrégoire

場合がないが、プログラムはまだ動作するかどうかint種類が無制限だった
ジョー・キング

1
@JoKing OK、最初に計算を行うために2つのソリューションを再度切り替えました。
オリビエグレゴワール

3

x86アセンブリ、45 43バイト。

6A 00 31 C9 31 D2 41 39  C1 7D 0B 50 F7 F9 58 85
D2 75 F1 51 EB EE 31 D2  59 01 CA 85 C9 75 F9 39
D0 75 05 31 C0 40 EB 02  31 C0 C3

説明(Intel構文):

PUSH $0          ; Terminator for later
XOR ECX, ECX        ; Clear ECX
.factor:
    XOR EDX, EDX    ; Clear EDX
    INC ECX
    CMP ECX, EAX    ; divisor >= input number?
    JGE .factordone ; if so, exit loop.
    PUSH EAX        ; backup EAX
    IDIV ECX        ; divide EDX:EAX by ECX, store result in EAX and remainder in EDX
    POP EAX         ; restore EAX
    TEST EDX, EDX   ; remainder == 0?
    JNZ .factor     ; if not, jump back to loop start
    PUSH ECX        ; push factor
    JMP .factor     ; jump back to loop start
.factordone:
XOR EDX, EDX        ; clear EDX
.sum:
    POP ECX         ; pop divisor
    ADD EDX, ECX    ; sum into EDX
    TEST ECX, ECX   ; divisor == 0?
    JNZ .sum        ; if not, loop.
CMP EAX, EDX        ; input number == sum?
JNE .noteq          ; if not, skip to .noteq
    XOR EAX, EAX    ; clear EAX
    INC EAX         ; increment EAX (sets to 1)
JMP .return         ; skip to .return
.noteq:
    XOR EAX, EAX    ; clear EAX
.return:
RETN

入力はで提供する必要がありますEAX
関数は完全なものと不完全なものに設定EAX10ます。

編集:と置換MOV EAX, $1することにより、バイト数を2つ減らしましたXOR EAX, EAXINC EAX


1
私は確かに知っていないので、マクロアセンブリを使用しますが、コメント「;除数>入力番号」私のためには以下のようになります「;除数> =入力番号」
RosLuP

アセンブリは1つが、すべてのライン内の命令長プットを減らす利用インデントとすべての10の20のasm命令....コメントでき簡単な操作がある
RosLuP

@RosLuPコード内のコメントを修正しました(ありがとう)が、2番目のコメントの意味がわかりません。
Fayti1703

3

ラビリンス、80バイト

?::`}:("(!@
perfect:
{:{:;%"}
+puts; "
}zero: "
}else{(:
"negI"  _~
""""""{{{"!@

ラテン文字perfect puts zero else neg Iは実際には単なるコメントです*。
すなわち、入力が完全な0場合-1はa が印刷され、そうでない場合は印刷されます。

オンラインでお試しください!


*だからこれこれも機能する...

?::`}:("(!@               ?::`}:("(!@
       :                  BEWARE :
{:{:;%"}                  {:{:;%"}
+    ; "                  +LAIR; "
}    : "                  } OF : "
}    {(:                  }MINO{(:
"    "  _~                "TAUR"  _~
""""""{{{"!@              """"""{{{"!@

どうやって?

入力として正の整数nを取り、アキュムレータ変数を-n補助スタックに配置しn-1てから、各整数に対して、アキュムレータに1除算nを行うものを追加し、それを含めて除算テストを実行します。アキュムレータ変数がゼロ以外の場合、これが完了する-1とa が出力され、そうでなければa 0が出力されます。

?::`}:(唯一の実行の開始時に、一度だけ実行されます。

?::`}:(                                                      Main,Aux
?       - take an integer from STDIN and place it onto Main  [[n],[]]
 :      - duplicate top of Main                            [[n,n],[]]
  :     - duplicate top of Main                          [[n,n,n],[]]
   `    - negate top of Main                            [[n,n,-n],[]]
    }   - place top of Main onto Aux                       [[n,n],[-n]]
     :  - duplicate top of Main                          [[n,n,n],[-n]]
      ( - decrement top of Main                        [[n,n,n-1],[-n]]

次の命令"は何もしませんが、3つの隣接する命令があるため、Mainの最上部の値に従って分岐します。ゼロは前方に進み、ゼロ以外は正しくなります。

1Mainの上部がゼロであるため、入力が先に進んだ場合:

(!@                                                          Main,Aux
(   - decrement top of Main                             [[1,1,-1],[-1]]
 !  - print top of Main, a -1
  @ - exit the labyrinth

しかし1、Mainの最上部がゼロ以外であるために入力が右折よりも大きかった場合:

:}                                                           Main,Aux
:  - duplicate top of Main                         [[n,n,n-1,n-1],[-n]]
 } - place top of Main onto Aux                        [[n,n,n-1],[-n,n-1]]

この時点で3つの隣のブランチがありn-1ますが、ゼロでないことがわかっているので、右に曲がります...

"%                                                           Main,Aux
"  - no-op                                             [[n,n,n-1],[-n,n-1]]
 % - place modulo result onto Main                   [[n,n%(n-1)],[-n,n-1]]
   - ...i.e we've got our first divisibility indicator n%(n-1), an
   -    accumulator, a=-n, and our potential divisor p=n-1:
   -                                                 [[n,n%(n-1)],[a,p]]

私たちは今、別の3つの隣の支店にい%ます。

の結果が%ゼロ以外の場合、潜在的な除数、をデクリメントしp=p-1、アキュムレータ、そのaままにします:

;:{(:""}"                                                    Main,Aux
;          - drop top of Main                                [[n],[a,p]]
 :         - duplicate top of Main                         [[n,n],[a,p]]
  {        - place top of Aux onto Main                  [[n,n,p],[a]]
           - three-neighbour branch but n-1 is non-zero so we turn left
   (       - decrement top of Main                     [[n,n,p-1],[a]]
    :      - duplicate top of Main                 [[n,n,p-1,p-1],[a]]
     ""    - no-ops                                [[n,n,p-1,p-1],[a]]
       }   - place top of Main onto Aux                [[n,n,p-1],[a,p-1]]
        "  - no-op                                     [[n,n,p-1],[a,p-1]]
         % - place modulo result onto Main           [[n,n%(p-1)],[a,p-1]]
           - ...and we branch again according to the divisibility
           -    of n by our new potential divisor, p-1

...しかし、の結果%がゼロの場合(最初のパスの場合のみn=2)、両方にまっすぐ進み、除数をアキュムレータに追加し、a=a+p潜在的な除数を減らしますp=p-1

;:{:{+}}""""""""{(:""}                                       Main,Aux
;                      - drop top of Main                    [[n],[a,p]]
 :                     - duplicate top of Main             [[n,n],[a,p]]
  {                    - place top of Aux onto Main      [[n,n,p],[a]]
   :                   - duplicate top of Main         [[n,n,p,p],[a]]
    {                  - place top of Aux onto Main  [[n,n,p,p,a],[]]
     +                 - perform addition            [[n,n,p,a+p],[]]
      }                - place top of Main onto Aux      [[n,n,p],[a+p]]
       }               - place top of Main onto Aux        [[n,n],[a+p,p]]
        """""""        - no-ops                            [[n,n],[a+p,p]]
                       - a branch, but n is non-zero so we turn left
               "       - no-op                             [[n,n],[a+p,p]]
                {      - place top of Aux onto Main      [[n,n,p],[a+p]]
                       - we branch, but p is non-zero so we turn right
                 (     - decrement top of Main         [[n,n,p-1],[a+p]]
                  :    - duplicate top of Main     [[n,n,p-1,p-1],[a+p]]
                   ""  - no-ops                    [[n,n,p-1,p-1],[a+p]]
                     } - place top of Main onto Aux    [[n,n,p-1],[a+p,p-1]]

この時点で、p-1まだゼロでない場合、左に曲がります:

"%                                                           Main,Aux
"  - no-op                                             [[n,n,p-1],[a+p,p-1]]
 % - modulo                                          [[n,n%(p-1)],[a+p,p-1]]
   - ...and we branch again according to the divisibility
   -    of n by our new potential divisor, p-1

...しかし、p-1ゼロにヒットした場合:、迷路の2行目までまっすぐ進みます(すべての指示を以前に見たことがありますので、説明を省略し、効果を与えるだけです):

:":}"":({):""}"%;:{:{+}}"""""""{{{                           Main,Aux
:                                  -                   [[n,n,0,0],[a,0]]
 "                                 -                   [[n,n,0,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
  :                                -                 [[n,n,0,0,0],[a,0]]
   }                               -                   [[n,n,0,0],[a,0,0]]
                                   - top of Main is zero so we go straight
    ""                             -                   [[n,n,0,0],[a,0,0]]
      :                            -                 [[n,n,0,0,0],[a,0,0]]
       (                           -                [[n,n,0,0,-1],[a,0,0]]
        {                          -              [[n,n,0,0,-1,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
         (                         -             [[n,n,0,0,-1,-1],[a,0]]
          :                        -          [[n,n,0,0,-1,-1,-1],[a,0]]
           ""                      -          [[n,n,0,0,-1,-1,-1],[a,0]]
             }                     -             [[n,n,0,0,-1,-1],[a,0,-1]]
                                   - top of Main is non-zero so we turn left
              "                    -             [[n,n,0,0,-1,-1],[a,0,-1]]
               %                   - (-1)%(-1)=0     [[n,n,0,0,0],[a,0,-1]]
                ;                  -                   [[n,n,0,0],[a,0,-1]]
                 :                 -                 [[n,n,0,0,0],[a,0,-1]]
                  {                -              [[n,n,0,0,0,-1],[a,0]]
                   :               -           [[n,n,0,0,0,-1,-1],[a,0]]
                    {              -         [[n,n,0,0,0,-1,-1,0],[a]]
                     +             -           [[n,n,0,0,0,-1,-1],[a]]
                      }            -              [[n,n,0,0,0,-1],[a,-1]]
                       }           -                 [[n,n,0,0,0],[a,-1,-1]]
                        """""""    -                 [[n,n,0,0,0],[a,-1,-1]]
                                   - top of Main is zero so we go straight
                               {   -              [[n,n,0,0,0,-1],[a,-1]]
                                {  -           [[n,n,0,0,0,-1,-1],[a]]
                                 { -         [[n,n,0,0,0,-1,-1,a],[]]

今、これに{は3つの隣接する命令があるので...

... if aがゼロの場合、これは完全なものになるためn、直進します。

"!@                                                          Main,Aux
"   -                                        [[n,n,0,0,0,-1,-1,a],[]]
    - top of Main is a, which is zero, so we go straight
 !  - print top of Main, which is a, which is a 0
  @ - exit the labyrinth

... if aが非ゼロの場合、これはnon-perfect nになりますので、左に曲がります:

_~"!@                                                        Main,Aux
_     - place a zero onto Main             [[n,n,0,0,0,-1,-1,a,0],[]]
 ~    - bitwise NOT top of Main (=-1-x)   [[n,n,0,0,0,-1,-1,a,-1],[]]
  "   -                                   [[n,n,0,0,0,-1,-1,a,-1],[]]
      - top of Main is NEGATIVE so we turn left
   !  - print top of Main, which is -1
    @ - exit the labyrinth


2

Javascript、62

n=>n==[...Array(n).keys()].filter(a=>n%a<1).reduce((a,b)=>a+b)

説明(非常に簡単ですが)

n=> //return function that takes n
  n== //and returns if n is equal to
    [...Array(n).keys()] //an array [0..(n-1)]...
      .filter(a=>n%a<1) //where all of the elements that are not divisors of n are taken out...
      .reduce((a,b)=>a+b) //summed up

改善してくれたジョー・キングに感謝します!




2

C(gcc)、41バイト

f(n,i,s){for(i=s=n;--i;s-=n%i?0:i);n=!s;}

オンラインでお試しください!

1: 0
12: 0
13: 0
18: 0
20: 0
1000: 0
33550335: 0
6: 1
28: 1
496: 1
8128: 1
33550336: 1
-65536: 0 <---- Unable to represent final test case with four bytes, fails

最後のケースの失敗が問題かどうかを教えてください。



2
「出力は、許可されている任意の出力形式を通じて、2つの異なる一貫した値にすることができます。」2つの異なる値を返していません。
オリビエグレゴワール

2
@OlivierGrégoire幸いなことに、スペースを感嘆符に置き換えることで簡単に修正できます!
ニール

1
@Neilさらに良いことに、5バイトを節約するn=!s;代わりにで修正できreturn!s;ます。

@OlivierGrégoireああ、私はその点を忘れていました。また、改善されたコードで更新しました。私は似たようなことを試しましたが、私がやったばかはs=s、おそらく最適化されました。
マルコス


2

Forth(gforth)、45バイト

: f 0 over 1 ?do over i mod 0= i * - loop = ;

オンラインでお試しください!

説明

1からn-1までのすべての数値をループし、nを完全に分割するすべての値を合計します。合計がnに等しい場合にtrueを返します

コードの説明

: f                \ start word definition
  0 over 1         \ create a value to hold the sum and setup the bounds of the loop
  ?do              \ start a counted loop from 1 to n. (?do skips if start = end)
    over           \ copy n to the top of the stack
    i mod 0=       \ check if i divides n perfectly
    i * -          \ if so, use the fact that -1 = true in forth to add i to the sum
  loop             \ end the counted loop
  =                \ check if the sum and n are equal
;                  \ end the word definition

2

Pyth、9 13バイト

qsf!%QTSt

オンラインでお試しください!

ゴルフのヘルプの解説者に感謝します

入力のすべての要因を見つけて合計し、それを元の入力と比較します。


あなたのためのいくつかのgolfsは- q0に置き換えることができ!、およびSQ範囲を生成し[1-Q]、その範囲を[1-Q)使用して生成することができますStQQsが、彼らは両方とも省略することができるプログラムの最後になりました。Fettledバージョン、9バイト-qsf!%QTSt
ソック

1

バッチ、81バイト

@set s=-%1
@for /l %%i in (1,1,%1)do @set/as+=%%i*!(%1%%%%i)
@if %s%==%1 echo 1

テイクnコマンドラインパラメータおよび出力として1、それは完全数である場合。ブルートフォース法は、ループ内-nn自分自身を含めることができるように合計を開始します。


1

、13バイト

Nθ⁼θΣΦθ∧ι¬﹪θι

オンラインでお試しください!リンクは、コードの詳細バージョンです。-完全な数値の出力。総当たり攻撃を使用します。説明:

Nθ              Numeric input
     Φθ         Filter on implicit range
        ι       Current value (is non-zero)
       ∧        Logical And
           θ    Input value
          ﹪     Modulo
            ι   Current value
         ¬      Is zero
    Σ           Sum of matching values
  ⁼             Equals
   θ            Input value


1

Pyth、8バイト

qs{*MPyP

こちらからオンラインでお試しください。

qs{*MPyPQQ   Implicit: Q=eval(input())
             Trailing QQ inferred
       PQ    Prime factors of Q
      y      Powerset
     P       Remove last element - this will always be the full prime factorisation
   *M        Take product of each
  {          Deduplicate
 s           Sum
q        Q   Is the above equal to Q? Implicit print

1

Retina 0.8.2、44バイト

.+
$*
M!&`(.+)$(?<=^\1+)
+`^1(1*¶+)1
$1
^¶+$

オンラインでお試しください!総当たり攻撃を使用するため、リンクには高速なテストケースのみが含まれます。説明:

.+
$*

単項に変換します。

M!&`(.+)$(?<=^\1+)

入力のすべての要因に一致します。これはオーバーラップモードを使用します。Retina0.8.2では、すべての一致を異なる位置から開始する必要があるため、実際には一致は元の入力から降順で返されます。

+`^1(1*¶+)1
$1

入力から適切な因子を引きます。

^¶+$

結果がゼロかどうかをテストします。



弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.