.png.c9b8f3e9eda461da3c0e9ca5ff8c6888.png)
1。ミス
1.Sudoku_easy
シンプルな数独身、注意を払うためのいくつかの小さなポイント、各レベルが送信されてから5秒後に睡眠をとって、質問が眠りに返されます
形を次のようにします
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -
800103720
023840650
410006008
300001062
0052407
072060090
160000375
205019846
000030000
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -
2次元配列に変換して数独を解き、戻り結果をマルチライン文字列に再変換します
def parse_input（input_list）:
ボード=[]
input_list:の行
nums=list（map（int、row））
board.append（nums）
返品ボード
def format_output（board）:
formatted=''
ボード:の行
formatted +='' .join（map（str、row）） + '\ n'
return formatted.strip（）
最初は、5ポイントを獲得するたびに120ポイントを獲得する必要があり、24回の範囲を持っていると思いましたが、問題を抱えていました。その後、スコアが増加したことがわかりました。同時に、私はデバッグし、120ポイントを獲得した場合、ゲッシェルを返すため、範囲を7回変更したことがわかりました。
最終スクリプト:
def find_empty（board）:
範囲の行（9）:の場合
範囲のcol（9）:の場合
ボード[row] [col]==0:の場合
Return Row、col
なしなし
def is_valid（board、num、pos）:
行、col=pos
範囲のIの場合（9）:
ボード[row] [i]==numおよびcol！=i:の場合
falseを返します
ボード[i] [col]==num and row！=i:の場合
falseを返します
box_row=row //3
box_col=col //3
範囲のi（box_row * 3、box_row * 3 + 3）:
range（box_col * 3、box_col * 3 + 3）:の場合
ボード[i] [j]==numおよび（i、j）！=pos:の場合
falseを返します
trueを返します
def solve（board）:
find=find_empty（ボード）
find:がない場合
trueを返します
else:
行、col=find
範囲（1、10）:のIの場合
is_valid（board、i、（row、col））:の場合
ボード[row] [col]=i
解決（ボード）:の場合
trueを返します
ボード[row] [col]=0
falseを返します
def parse_input（input_list）:
ボード=[]
input_list:の行
nums=list（map（int、row））
board.append（nums）
返品ボード
def format_output（board）:
formatted=''
ボード:の行
formatted +='' .join（map（str、row）） + '\ n'
return formatted.strip（）
＃input_string='' '-------------------------
＃800103720
＃023840650
＃410006008
＃300001062
＃000052407
＃072060090
＃160000375
＃205019846
＃000030000
＃----------------------------
＃今、私にあなたがsolve: '' 'を与えてください
＃リスト=input_string.split（ '\ n'）[1:10]
＃ボード=parse_input（lists）
＃印刷（ボード）
＃solve（ボード）
＃印刷（ボード）
PWNインポートから *
＃接続を作成します
conn=remote（'47 .108.165.60 '、27539）
＃ウェルカムメッセージを受け取ります
範囲のIの場合（7）:
msg=conn.recvuntil（ '入力:'）。ストリップ（）。デコード（ 'utf-8'）
印刷（msg）
＃選択を送信します
conn.sendline（ '1'.encode（））
＃次のプロンプトを受信します
msg=conn.recvuntil（ 'level:'を選択してください）。ストリップ（）。デコード（ 'utf-8'）
印刷（msg）
conn.sendline（ '5'.encode（））
msg=conn.recvuntil（ 'clock start'）。strip（）。decode（ 'utf-8'）
印刷（msg）
time.sleep（5）
msg=conn.recvuntil（ '今私にsolve:'を与えます）。sprip（）。decode（ 'utf-8'）
印刷（msg）
lists=msg.split（ '\ n'）[1:10]
board=parse_input（lists）
SOLVE（ボード）
solved=format_output（board）
conn.sendline（solved.encode（））
conn.Interactive（）
または
PWNインポートから *
def is_valid（board、row、col、num）:
＃行が合法かどうかを確認してください
範囲のIの場合（9）:
ボード[row] [i]==num:の場合
falseを返します
＃列が合法かどうかを確認してください
範囲のIの場合（9）:
ボード[i] [col]==num:の場合
falseを返します
＃9番目の広場が合法かどうかを確認してください
start_row=（row //3） * 3
start_col=（col //3） * 3
範囲のIの場合（3）:
範囲（3）:のJの場合
ボード[start_row + i] [start_col + j]==num:の場合
falseを返します
trueを返します
def solve_sudoku（ボード）:
範囲の行（9）:の場合
範囲のcol（9）:の場合
ボード[row] [col]==0:の場合
範囲のnum（1、10）:の場合
is_valid（Board、row、col、num）:の場合
ボード[row] [col]=num
solve_sudoku（ボード）:の場合
trueを返します
ボード[row] [col]=0＃バックトラッキング
falseを返す＃すべての数字が試され、適切な数字が見つかりませんでした
trueを返します
def print_sudoku（board）:
a=''
範囲の行（9）:の場合
範囲のcol（9）:の場合
a +=str（board [row] [col]）
a+='\ n'
A.Strip（）を返します
context.log_level='debug'
p=remote（'47 .108.165.60 '、23479）
p.recv（）
範囲のIの場合（7）:
P.Sendline（ '1'）
P.Recvuntil（ 'レベル:を選択してください'）
P.Sendline（ '5'）
a='------------------- \ nnow shive you solve:'
content=p.recvuntil（a）.decode（）。分割（a）[0] [-130:]
sudoku=content.split（ '-------------------'）[1]
sudoku=sudoku.strip（）
sudoku=sudoku.split（ '\ n'）
tmp=[]
sudoku:のsudoの場合
a=sudoのsの[int（s）]
TMP.Append（a）
solve_sudoku（tmp）:の場合
result=print_sudoku（tmp）
log.info（結果）
result.split（ '\ n'）:のラインの場合
p.send（line）
#content=p.recv（）。decode（）
p.interactive（）
独立した数独復号化スクリプト：
クラスsudoku（）:
def __init __（self、sudo_ku_data）:
ISInstanceではない場合（sudo_ku_data、list）:
Raise TypeError（f'sudo_ku_data paramsはリストでなければなりませんが、{sudo_ku_data}は{type（sudo_ku_data）} 'です。
Len（sudo_ku_data）！=9またはlen（sudo_ku_data [0]）！=9:の場合
タイプエラーを上げる（
f'sudo_ku_data paramsは9*9のリストでなければなりませんが、{sudo_ku_data}は{len（sudo_ku_data）}*{len（sudo_ku_data [0]）} list '）です。
self.sudo_ku=sudo_ku_data
＃既存のデータを各行に保存します
self.envery_row_data={}
＃各列の既存の数字
self.every_column_data={}
＃3*3ごとに
self.envery_three_to_three_data={}
＃空席の場所
self.vacant_position=[]
＃各空席で試した数字
self.every_vacant_position_tried_values={}
＃データを初期化します
self._init（）
def _add_row_data（self、row、value）:
'' '
初期化の場合
self.envery_row_dataにデータを追加します
:param row:
:Param Value:
:RETURN:
'' '
rowがself.envery_row_data:にない場合
self.every_row_data [row]=set（）
self.envery_row_data [row] :の値の場合
Raise TypeRror（f'params {self.sudo_ku}は無効な数独'）
self.every_row_data [row] .add（value）
def _add_column_data（self、column、value）:
'' '
初期化の場合
self.envery_column_dataにデータを追加します
:Param Column:
:Param Value:
:RETURN:
'' '
columnがself.envery_column_data:にない場合
self.every_column_data [column]=set（）
self.envery_column_data [列] :の値の場合
Raise TypeRror（f'params {self.sudo_ku}は無効な数独'）
self.every_column_data [column] .add（value）
def _get_three_to_three_key（self、row、column）:
'' '
3*3キーごとに取得します
:param row:
:Param Column:
:RETURN:
'' '
[0、1、2] :の行の場合
[0、1、2] :の列の場合
key=1
[3、4、5] :の列列
key=2
else:
key=3
[3、4、5] :のElif Row
[0、1、2] :の列の場合
キー=4
[3、4、5] :の列列
key=5
else:
key=6
else:
[0、1、2] :の列の場合
key=7
[3、4、5] :の列列
key=8
else:
key=9
キーを返します
def _add_three_to_three_data（self、row、column、value）:
'' '
初期化の場合
self.envery_three_to_three_dataにデータを追加します
:param row:
:Param Column:
:Param Value:
:RETURN:
'' '
key=self._get_three_to_three_key（列、列）
key.enty.envery_three_to_three_data:ではない場合
self.every_three_to_three_data [key]=set（）
self.every_three_to_three_data [key] .add（value）
def _init（self）:
'' '
入ってくる数独に基づいてデータを初期化します
:RETURN:
'' '
rowの場合、row_datas in enumerate（self.sudo_ku）:
列の場合、値の値（row_datas）:
value=='' :の場合
self.vacant_position.append（（列、列））
else:
self._add_row_data（row、value）
self._add_column_data（列、値）
self._add_three_to_three_data（row、column、value）
def _judge_value_is_legal（self、row、column、value）:
'' '
当事者によって配置されたデータが合法かどうかを判断する
:param row:
:Param Column:
:Param Value:
:RETURN:
'' '
＃このデータの行に値は存在しますか
self.envery_row_data [row] :の値の場合
falseを返します
＃このデータの列に値は存在しますか
self.envery_column_data [列] :の値の場合
falseを返します
＃値この3*3の宮殿は存在しますか？
key=self._get_three_to_three_key（列、列）
self.envery_three_to_three_data [key] :の値の場合
falseを返します
trueを返します
def _calculate（self、vacant_position）:
'' '
計算して、数独に値の配置を開始します
:PARAM VACANT_POSITION:
:RETURN:
'' '
＃現在の場所を取得します
行、列=facant_position
値=set（範囲（1、10））
＃現在の場所が現在の場所で試されたデータを保存するための一意のキーを作成します
key=str（row） + str（列）
＃このキーが存在する場合は、値の差を取得します。両方ともセットであるため、直接使用するだけです -
self.envery_vacant_position_tried_values:のキーの場合
値=values-self.envery_vacant_position_tried_values [key]
＃このキーが存在しない場合は、空のコレクションを作成します
else:
self.every_vacant_position_tried_values [key]=set（）
値の値:
＃現在のデータを現在の場所で試されたデータに追加します
self.every_vacant_position_tried_values [key] .add（value）
＃現在の値が合法である場合、配置できます
self._judge_value_is_legal（row、column、value）:の場合
＃print（f'set {vacant_position}値は{値} '）