時間があったので挑戦し、その結果をまとめてみましたので投稿致します。

次回受験される方の一助になれば幸いです。

問  1

X←1
Y←2
Z←3

X←Y    X←2
Y←Z    Y←3
Z←X    Z←2

なので、Y,Z  は  3,2  になります。

問  2

引数で与えられた数が、3,5で割り切れるかどうかで４つに分類します。

１  3で割り切れる（3で割り切れ、5で割り切れない）
２  5で割り切れる（5で割り切れ、3で割り切れない）
３  3と5で割り切れる（3,5 どちらでも割り切れる）
４  3でも5でも割り切れない

ここで、３の条件は、１，２の条件に含まれるので１，２より判定を後にすると
３は分類できません。そのため、３の条件判定を最初に行います。
解答群の中で最初に３の条件判定を行っているのは、ウだけです。

その後、１，２の条件判定は、どちらが先でも構いません。

問  3

配列  in[1]=3,in[2]=2,in[3]=1,in[4]=6,in[5]=5,in[6]=4
要素数は、6です。

outの値をトレースしていきます。
out={}
末尾にin[1]を追加      out={3}
i=2
      tail←out[outの要素数]=out[1]=3
      outの末尾に(tail+in[2]=3+2=5)を追加
      out={3,5}
i=3
      tail←out[outの要素数]=out[2]=5
      outの末尾に(tail+in[3]=5+1=6)を追加
      out={3,5,6}
i=4
      tail←out[outの要素数]=out[3]=6
      outの末尾に(tail+in[4]=6+6=12)を追加
      out={3,5,6,12}
i=5
      tail←out[outの要素数]=out[4]=12
      outの末尾に(tail+in[5]=12+5=17)を追加
      out={3,5,6,12,17}
i=6
      tail←out[outの要素数]=out[5]=17
      outの末尾に(tail+in[6]=17+4=21)を追加
      out={3,5,6,12,17,21}
end
return out={3,5,6,12,17,21}

よって、outの要素番号5の値は、17になります。

（別解）
outの末尾にin[1]を追加→out[1]=in[1]
i=2
      tail←out[1]=in[1]
      outの末尾に(tail+in[2])を追加→out[2]=tail+in[2]=in[1]+in[2]
i=3
      tail←out[2]=in[1]+in[2]
      outの末尾に(tail+in[3])を追加→out[3]=tail+in[3]=in[1]+in[2]+in[3]
・・・・
i=5
      tail←out[4]=in[1]+in[2]+in[3]+in[4]
      outの末尾に(tail+in[5])を追加→out[5]=tail+in[5]=in[1]+in[2]+in[3]+in[4]+in[5]

ようするに、outの要素番号5の値は、inの要素を先頭から5番目まで足せば求められます。

問  4

a,cについては、ifだとループが1回しか実行されません。1回で最大公約数が見つかるとは限らないので、不適です。
ア、イは、×

bの条件
二つの正の数の最大公約数を求めるので、負の数は出てきません。
条件が成り立つときはx-yを実行し、成り立たないときy-xを実行するので、x>yが条件に当てはまります。

問  5

x^2=pow(x,2)
y^2=pow(y,2)
x^2+y^2=pow(x,2)+pow(y,2)
ルートは、1/2乗なので、
z^(1/2)=pow(z,1/2)=pow(z,0.5)
zにx^2+y^2を代入すると、
pow(z,0.5)=pow(x^2+y^2,0.5)=pow(pow(x,2)+pow(y,2),0.5)

この投稿は投稿者により削除されました。(2023.01.01 16:40)

問  9
まず、treeについて確認しておきます。
tree[1]={2,3}    要素数2
tree[2]={4,5}    要素数2
tree[3]={6,7}    要素数2
tree[4]={8,9}    要素数2
tree[5]={10,11}    要素数2
tree[6]={12,13}    要素数2
tree[7]={14}    要素数1
tree[8]～tree[14]={}    要素数0
です。

order(1)を実行します。
    tree[1]の判定  
    tree[1]={2,3}    要素数2  なので
    order(tree[1][1]=2)
        tree[2]の判定  
        tree[2]={4,5}    要素数2  なので
        order(tree[2][1]=4)
            tree[4]の判定
            tree[4]={8,9}    要素数2  なので
            order(tree[4][1]=8)
                tree[8]の判定
                tree[8]={}    要素数0  なので
＊              8を出力
            endif
＊          4を出力
            *****自信があればここまでで解答できます。
            order(tree[4][2]=9)
                tree[9]の判定
                tree[9]={}    要素数0  なので
＊              9を出力
            endif
＊      2を出力
        order(tree[2][2]=5)
            tree[5]の判定
            tree[5]={10,11}    要素数2  なので
            order(tree[5][1]=10)
                tree[10]の判定
                tree[10]={}    要素数0  なので
＊              10を出力
            endif
＊          5を出力
            order(tree[5][2]=11)
                tree[11]の判定
                tree[11]={}    要素数0  なので
＊              11を出力
            endif
        endif
＊  1を出力
    order(tree[1][2]=3)
        tree[3]の判定  
        tree[3]={6,7}    要素数2  なので
        order(tree[3][1]=6)
            tree[6]の判定
            tree[6]={12,13}    要素数2  なので
            order(tree[6][1]=12)
                tree[12]の判定
                tree[12]={}    要素数0  なので
＊              12を出力
            endif
＊          6を出力
            order(tree[6][2]=13)
                tree[13]の判定
                tree[13]={}    要素数0  なので
＊              13を出力
            endif
＊      3を出力
        order(tree[3][2]=7)
            tree[7]の判定
            tree[7]={14}    要素数1  なので
            order(tree[7][1]=14)
                tree[14]の判定
                tree[14]={}    要素数0  なので
＊              14を出力
            endif
＊          7を出力
        endif
    endif

＊のところで、出力されます。

バイナリサーチの通りがけ順と同じ順で取り出しています。
（２分木ではないので、昇順にはなりません。）

問  10
プログラムをトレースします。
pos=1（先頭を削除するとき）
現在の先頭が次に参照している要素が、先頭になるので
ListHead←ListHead.next
pos=2
prevが、先頭要素の参照
prev.nextが２番目の要素の参照
prev.next.nextが３番目の要素の参照
２番目を削除するので、
prev.next.nextでprev.nextを置き換える。（２番目を抜かす。）

posが3以上の時
forループで、prevを削除したい要素の位置の直前にする。
次の要素を削除したいので、次の要素を参照するprev.nextを
次の次の要素を参照するprev.next.nextに置き換える

問  11
ループ中のdata[i]に同じ値があるとbins[data[i]]が上書きされてしまい、binsの中に未定義の要素が残ってしまいます。
同じ値のない  ア  が答えになります。

問  12
問題文の（要素番号が同じ要素の文字同士が一致する）を式で表すとs1[i]=s2[i]になります。
一致した個数をを数えるのが、cnt←cnt+1になるので、if文の条件には、s1[i]=s2[i]が当てはまります。

問  13
ア：Low=1,high=1,middle=1なのでdata[1]=targetとなり  return  1
イ：Low=1,high=2,middle=1なのでdata[1]=targetとなり  return  1
ウ：Low=1,high=2,middle=1なのでdata[middle]=data[1]<targetとなり
    Low←middle=1でLow=1となる。同じ条件に戻るので繰り返し、無限ループになる。
エ：dataの中身については、正負の制限はありません。昇順に整列されていて、重複がなければよい。

不具合は、ループの中でLowやhighを設定するところです。
data[middle]<targetの場合、data[middle]は対象外なので、次はdata[middle+1]から調べれば十分です。
なので、low←middle+1にします。
data[middle]>targetの場合、data[middle]は対象外なので、次はdata[middle-1]まで調べれば十分です。
なので、high←middle-1にします。
こうすれば、ウの場合２回目のループでは、Low=2となり
Low=2,high=2,middle=2なのでdata[middle]=data[2]=targetとなり  return  2

問  14
sortedData[]={0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1}
rankData[]={}
p[]={0,0.25,0.5,0.75,1}

トレースします。

i=1
    rankDataの末尾に、
    findRank(sortedData,p[1])の戻り値を追加
        i←p[1]x9=0
        return sortedData[1]=0.1
    rankData[]={0.1}
i=2
    rankDataの末尾に、
    findRank(sortedData,p[2])の戻り値を追加
        p[2]x9=0.25x9=2.25
        i←3
        return sortedData[4]=0.4
    rankData[]={0.1,0.4}
i=3
    rankDataの末尾に、
    findRank(sortedData,p[3])の戻り値を追加
        p[3]x9=0.5x9=4.5
        i←5
        return sortedData[6]=0.6
    rankData[]={0.1,0.4,0.6}
i=4
    rankDataの末尾に、
    findRank(sortedData,p[4])の戻り値を追加
        p[4]x9=0.75x9=6.75
        i←7
        return sortedData[8]=0.8
    rankData[]={0.1,0.4,0.6,0.8}
i=5
    rankDataの末尾に、
    findRank(sortedData,p[5])の戻り値を追加
        p[5]x9=9
        i←9
        return sortedData[10]=1
    rankData[]={0.1,0.4,0.6,0.8,1}

解答群の中の  ク  になります。

問  15
手順にそって評価値を決定していきます。

４段目    決定済み    ０、１０、ーーー、０
３段目    自分の手番なので、（３）の①を適用し、
          左から順に、０、１０、－１０、０
２段目    相手の手番なので、（３）の②を適用し、
          左側の０、１０では、０を選択→a
          右側の－１０、０では、－１０を選択する。→b

問  16
ビット列と合わせて考えてみます。

utf8Bytes[1]=224(10)=11100000(2)
utf8Bytes[2]=128(10)=10000000(2)
utf8Bytes[3]=128(10)=10000000(2)
cp=xxxxyyyyyyzzzzzz(2)
としたとき、

utf8Bytes[1]=1110xxxx(2)=X(10)
utf8Bytes[2]=10yyyyyy(2)=Y(10)
utf8Bytes[3]=10zzzzzz(2)=Z(10)
utf8Bytes={X,Y,Z}
を求めるプログラムです。

cpの下位から６桁ずつ取り出したいので、2^6=64 で割ってみます。
（ビット列で考えます。）
cp÷64を計算すると
商：xxxxyyyyyyzzzzzzを右に6シフトして、xxxxyyyyyy
余り：zzzzzz

続けて cpをxxxxyyyyyyに更新して
６４で割ると
商：xxxx
余り：yyyyyy

さらに cpをxxxxに更新して
６４で割ると
商：0
余り：xxxx

となり、うまいこと行きます。

四角には、2^6=64が当てはまります。

問  17
項番１  アプリケーションサーバのOS→B社
項番２  クロスサイトスクリプティング→Webアプリ→C社
項番３  DBMS→B社

問  18
前提条件：客先常駐開発部員に、個人所有PCからのVPN接続を許可した場合
で（一）から（五）まで順にチェックします。

（一）個人所有のPCが新たに加わるので、新たなリスクが生じます。
（二）個人所有のPCとは関係ありません。
（三）業務システムには、メール利用できるとは書いてありません。
（四）前提条件に総務部員は入っていません。
（五）考えられます。

（一）と（五）が当てはまるので、答えは  エ

問  19
                          与えられている権限(本文から)
Z販売課の販売責任者       閲覧・承認
商品ZのB社販売責任者      閲覧
商品ZのB社販売担当者      入力

入力ができるa2は、商品ZのB社販売担当者
閲覧だけできるa1は、商品ZのB社販売責任者
が、該当します。

問  20
指摘１：FWの運用の作業の中で、職務が適切に分離されていない。
この指摘を受けたのは、FWの運用状況の中の
・６名の運用担当者とも全権限を付与されており、運用担当者はFWのルールの編集後、編集を行った運用担当者が操作に誤りがないことを確認し、操作承認をしている。
の部分だと思います。（一人で編集～承認までできてしまう。間違えや不正が発生しやすい。）

FWルールの誤った変更を防ぐための改善策としては、カ  が適当。

問  6
イウエは、変換元のrbyteに対して、 >>7 のようなシフトをしたり、rで上書きしたり変換元のrbyteに不適切な操作をしているので×。
よって答えは、ア。

（別解  アのトレース）

８ビット型の数を、abcdefgh とします。
（アルファベットは、0または1）

abcdefgh  を  hgfedcba  に並び替えます。

アの手順を当てはめます。
初期状態
r=00000000
rbyte=abcdefgh

１回目
    (r<<1)=00000000
    (rbyte∩00000001)=0000000h
    r←(r<<1)V(rbyte∩00000001)=0000000h
    rbyte←rbyte>>1=0abcdefg
２回目
    (r<<1)=000000h0
    (rbyte∩00000001)=0000000g
    r←(r<<1)V(rbyte∩00000001)=000000hg
    rbyte←rbyte>>1=00abcdef
３回目
    (r<<1)=00000hg0
    (rbyte∩00000001)=0000000f
    r←(r<<1)V(rbyte∩00000001)=00000hgf
    rbyte←rbyte>>1=000abcde
・・・・・・
８回目
    (r<<1)=hgfedcb0
    (rbyte∩00000001)=0000000a
    r←(r<<1)V(rbyte∩00000001)=hgfedcba
    rbyte←rbyte>>1=00000000
ループが終わり、
return r=hgfedcba

結果、並び順が逆になります。

問  7
nの階乗
n!=nx(n-1)x(n-2)x......x2x1
イウエオは、ぱっと見、違うのでアとカについて調べます。

factorial(n)をf(n)と略記します。
ア：(n-1)xf(n)=(n-1)x(n-1)xf(n)=......  終わりません。
カ：nxf(n-1)=nx(n-1)xf(n-2)=nx(n-1)x(n-2)xf(n-3)=....=n!

問  8
キューの動きをトレースします。
enq      A1
enq      A1,B2
enq      A1,B2,C3
enq      A1,B2,C3,D3
deq      B2,C3,D3
deq      C3,D3
enq      C3,D3,D3
enq      C3,D3,D3,B2
deq      C3,D3,D3
deq      D3,D3
enq      D3,D3,C2
enq      D3,D3,C2,A1
このあと、残りのキューのdeqの戻り値を出力するので、
A1,C2,D3,D3と出力されます。（"A","C","D","D")

ありがとうございます。分かりやすいです

問13のイとウの違いが分かりません
イの場合
要素  
1  2    target
50  80   50
でトレースしました。先頭の50見つかった  ○

ウの場合
1  2    target
40  50   50
2つめ見つかったから無限ループになるのでしょうか？
2つめを探索しないのですか？

data={50,80}とします。

イの場合（target=50)
>if (data[middle] ＜ target)
data[middle]=data[1]=50,target=50なので条件式は偽
>elseif (data[middle] ＞ target)
data[middle]=data[1]=50,target=50なので条件式は偽
>else return middle
これが実行されmiddle=1を返却する。

ウの場合（target=80)
>if (data[middle] ＜ target)
data[middle]=data[1]=50,target=80なので条件式は真
よってlow ← middle=1（この処理の前後でlowが1のまま変わっていないことに注意）
>while (low ≦ high)
low=1,high=2なのでwhile文は継続
またlow=1,high=2なのでmiddleも1のまま変わらない
つまりループが1周してもlow,high,middleに変化がないため延々と同じことを繰り返すことになる（無限ループ）。

1   2    target
40  50   50
の場合

low←1
High←2
while文は、Low<Highなので
    middle←(1+2)÷2の商=1
    if文は、data[1]<targetなので
      low←middle=1
    endif
endwhile
となり、whileループを繰り返します。

この投稿は投稿者により削除されました。(2023.01.02 10:12)

>if(data[middle]＜target)
data[middle]=data[1]=50,target=80なので条件式は真
（条件揃った）
↓
このあとの流れはendwhileに行く
また
data[middle]=data[1]=50,target=80なので条件式は真
80を探しているのに50
このあとの流れはendwhileに行く
↓
また
data[middle]=data[1]=50,target=80なので条件式は真
80を探しているのに50
このあとの流れはendwhileに行く
と無限ループに入る

ipaの擬似言語処理の内容と問題が噛み合わず混乱してました
分かりやすい解説ありがとうございます。

ありがとうございます。
公式解説がなかったので、わからない問題をここで理解できるようにします。

Q9の二分木について質問です。

""order(1)を実行します。
    tree[1]の判定  
    tree[1]={2,3}    要素数2  なので
    order(tree[1][1]=2)""

ここで記されている、"tree[1][1]=2"の
示す意味がなぜそうなるのか、理解できずにいます。
[n][1]と[n][2]は何が違うのでしょうか。

>しゅうさん
ご覧いただきありがとうございます。

treeが、２次元配列になっているので、わかりづらいですが、
tree[n]をtreenという配列と考え、配列の要素をtreen[1]とtreen[2]のように考えると、
上の例では、
tree[1]=tree1={2,3}    要素数2の配列なので
    tree1[1]=2  表現を戻すと=tree[1][1]
    tree1[2]=3  表現を戻すと=tree[1][2]
みたいな感じになります。

ありがとうございます。
二次元配列でやっと理解できました。

参考書片手に解きまくります！

>boyonboyonさん
問11についてご質問があります。
「ループ中のdata[i]に同じ値があるとbins[data[i]]が上書きされてしまい、binsの中に未定義の要素が残ってしまいます。」とありますが、理解できなかったのでご教示いただけますと幸いです。
bins[data[i]] にdata[i]を入れてトレースしてみると以下のようになるかと思っていましたが違っているようですね。
例として解答イの値をトレースしてみました。
イ{3, 1, 4, 4, 5, 2}
  → 3(1)、1(2)、4(3)、4(4)、5(5)、2(6)

>はいさん

返信遅くなってすみません。
説明が言葉足らずでしたね。
トレースしてみましたので参考にしてください。

n=6なので
bins={6個の未定義の値}
になっています。

bins[data[1]]←data[1]
bins[data[2]]←data[2]
bins[data[3]]←data[3]
bins[data[4]]←data[4]
bins[data[5]]←data[5]
bins[data[6]]←data[6]
に、{3,1,4,4,5,2}を当てはめると

bins[3]←3
bins[1]←1
bins[4]←4
bins[4]←4
bins[5]←5
bins[2]←2
なので、

bins={1,2,3,4,5,未定義の値}
となり、未定義の要素が残ってしまい、条件に反します。

問11  の説明補足

「ループ中のdata[i]に同じ値があるとbins[data[i]]が上書きされてしまい、binsの中に未定義の要素が残ってしまいます」
のところですが、言い方を変えて
「data[i]に欠番があるとそれに対応するbinsが未定義のまま残ってしまいます。」
の方が分かりやすいですかね。

イの場合  6がないので、bins[6]が未定義のまま
ウの場合  3がないので、bins[3]が未定義のまま
エの場合  1がないので、bins[1]が未定義のまま
になってしまうので、条件に合いません。

>boyonboyonさん
ご回答ありがとうございます。
同じ要素があると、欠番になるんですね。

質問です
order(1)を実行します。
    tree[1]の判定  
    tree[1]={2,3}    要素数2  なので
    order(tree[1][1]=2)
        tree[2]の判定  
        tree[2]={4,5}    要素数2  なので
        order(tree[2][1]=4)
            tree[4]の判定
            tree[4]={8,9}    要素数2  なので
            order(tree[4][1]=8)
                tree[8]の判定
                tree[8]={}    要素数0  なので
＊              8を出力
            endif
＊        4を出力  ←ここの理由がわかりません。ご教授お願い致します。