C++로 만든 개인프로젝트이다.
// A Backtracking program in C++ to solve Sudoku problem
#include <bits/stdc++.h>
using namespace std;
// UNASSIGNED is used for empty cells in sudoku grid
#define UNASSIGNED 0
// N is used for the size of Sudoku grid. Size will be NxN
#define N 9
// This function finds an entry in grid that is still unassigned
bool FindUnassignedLocation(int grid[N][N], int& row, int& col);
// Checks whether it will be legal to assign num to the given row, col
bool isSafe(int grid[N][N], int row, int col, int num);
/* Takes a partially filled-in grid and attempts to assign values to all unassigned locations in
such a way to meet the requirements for Sudoku solution (non-duplication across rows,
columns, and boxes) */
bool SolveSudoku(int grid[N][N])
{
int row, col;
// If there is no unassigned location,
// we are done
if (!FindUnassignedLocation(grid, row, col)) {
// success!
return true;
}
// Consider digits 1 to 9
for (int num = 1; num <= 9; num++)
{
// Check if looks promising
if (isSafe(grid, row, col, num))
{
// Make tentative assignment
grid[row][col] = num;
// Return, if success
if (SolveSudoku(grid)) {
return true;}
// Failure, unmake & try again
grid[row][col] = UNASSIGNED;
}
}
// This triggers backtracking
return false;
}
/* Searches the grid to find an entry that is still unassigned. If found, the reference
parameters row, col will be set the location that is unassigned, and true is returned.
If no unassigned entries remain, false is returned. */
bool FindUnassignedLocation(int grid[N][N],
int& row, int& col)
{
for (row = 0; row < N; row++)
for (col = 0; col < N; col++)
if (grid[row][col] == UNASSIGNED)
return true;
return false;
}
/* Returns a boolean which indicates whether
an assigned entry in the specified row matches the given number. */
bool UsedInRow(int grid[N][N], int row, int num)
{
for (int col = 0; col < N; col++)
if (grid[row][col] == num)
return true;
return false;
}
/* Returns a boolean which indicates whether
an assigned entry in the specified column matches the given number. */
bool UsedInCol(int grid[N][N], int col, int num)
{
for (int row = 0; row < N; row++)
if (grid[row][col] == num)
return true;
return false;
}
/* Returns a boolean which indicates whether
an assigned entry within the specified 3x3 box matches the given number. */
bool UsedInBox(int grid[N][N], int boxStartRow, int boxStartCol, int num)
{
for (int row = 0; row < 3; row++)
for (int col = 0; col < 3; col++)
if (grid[row + boxStartRow]
[col + boxStartCol] ==
num)
return true;
return false;
}
/* Returns a boolean which indicates whether
it will be legal to assign num to the given row, col location. */
bool isSafe(int grid[N][N], int row, int col, int num)
{
/* Check if 'num' is not already placed in
current row, current column
and current 3x3 box */
return !UsedInRow(grid, row, num)
&& !UsedInCol(grid, col, num)
&& !UsedInBox(grid, row - row % 3,
col - col % 3, num)
&& grid[row][col] == UNASSIGNED;
}
/* A utility function to print grid */
void printGrid(int grid[N][N])
{
for (int row = 0; row < N; row++)
{
for (int col = 0; col < N; col++)
cout << grid[row][col] << " ";
cout << endl;
}
}
/* A utility function to print grid in a single row with no space in between*/
void printGrid2(int grid[N][N], char c)
{
for (int row = 0; row < N; row++)
{
for (int col = 0; col < N; col++) {
if ( grid[row][col] == 0 ) {
cout << c;
} else {
cout << grid[row][col];
}
}
}
cout << endl;
}
void initGrid(int grid[N][N])
{
for (int row = 0; row < N; row++)
{
for (int col = 0; col < N; col++) {
grid[row][col] = 0;
}
}
}
void randN(int arr[], int CNT ) {
for(int i =0 ; i < CNT; i++) {
arr[i] = 0;
}
srand((unsigned int) time(NULL));
for(int knt = 0; knt < CNT; ) {
int num = (rand() % CNT) + 1;
int flag = 0;
for( int a = 0; a < CNT; a++ ) {
if( arr[a] == num ) {
flag = 1;
break;
}
}
if( flag == 0 ) {
arr[knt++] = num;
}
}
}
void fillBox(int grid[N][N], int row,int col)
{
int knt = 0;
int arr[9];
randN(arr, 9 );
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
grid[row+i][col+j] = arr[knt++];
}
}
}
void fillZeros(int grid[N][N], int grid2[N][N],int CNT) {
int arr[81];
randN(arr, 81);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
grid2[i][j] = grid[i][j];
}
}
for (int i = 0; i < CNT; i++) {
int rn = arr[i];
int row = rn / 9;
int col = rn % 9;
grid2[row][col] = 0;
}
}
int main()
{
// 0 means unassigned cells
int grid[N][N];
int grid2[N][N];
initGrid(grid);
fillBox(grid, 0, 0);
fillBox(grid, 3, 3);
fillBox(grid, 6, 6);
if (SolveSudoku(grid) == true) {
fillZeros(grid, grid2, 40);
printGrid(grid); cout << endl;
printGrid2(grid2, '-');
printGrid2(grid, '@');
printGrid2(grid2, 'X');
} else {
cout << "No solution exists";
}
return 0;
}
ㅁㅁㅁㅁㅁㅁㅁㅁㅁㅁㅁ Solver ㅁㅁㅁㅁㅁㅁㅁㅁㅁㅁㅁ
// A Backtracking program in C++ to solve Sudoku problem
#include <bits/stdc++.h>
using namespace std;
// UNASSIGNED is used for empty cells in sudoku grid
#define UNASSIGNED 0
// N is used for the size of Sudoku grid. Size will be NxN
#define N 9
// This function finds an entry in grid that is still unassigned
bool FindUnassignedLocation(int grid[N][N], int& row, int& col);
// Checks whether it will be legal to assign num to the given row, col
bool isSafe(int grid[N][N], int row, int col, int num);
/* Takes a partially filled-in grid and attempts to assign values to all unassigned locations in
such a way to meet the requirements for Sudoku solution (non-duplication across rows,
columns, and boxes) */
bool SolveSudoku(int grid[N][N])
{
int row, col;
// If there is no unassigned location,
// we are done
if (!FindUnassignedLocation(grid, row, col)) {
// success!
return true;
}
// Consider digits 1 to 9
for (int num = 1; num <= 9; num++)
{
// Check if looks promising
if (isSafe(grid, row, col, num))
{
// Make tentative assignment
grid[row][col] = num;
// Return, if success
if (SolveSudoku(grid)) {
return true;}
// Failure, unmake & try again
grid[row][col] = UNASSIGNED;
}
}
// This triggers backtracking
return false;
}
/* Searches the grid to find an entry that is still unassigned. If found, the reference
parameters row, col will be set the location that is unassigned, and true is returned.
If no unassigned entries remain, false is returned. */
bool FindUnassignedLocation(int grid[N][N],
int& row, int& col)
{
for (row = 0; row < N; row++)
for (col = 0; col < N; col++)
if (grid[row][col] == UNASSIGNED)
return true;
return false;
}
/* Returns a boolean which indicates whether
an assigned entry in the specified row matches the given number. */
bool UsedInRow(int grid[N][N], int row, int num)
{
for (int col = 0; col < N; col++)
if (grid[row][col] == num)
return true;
return false;
}
/* Returns a boolean which indicates whether
an assigned entry in the specified column matches the given number. */
bool UsedInCol(int grid[N][N], int col, int num)
{
for (int row = 0; row < N; row++)
if (grid[row][col] == num)
return true;
return false;
}
/* Returns a boolean which indicates whether
an assigned entry within the specified 3x3 box matches the given number. */
bool UsedInBox(int grid[N][N], int boxStartRow, int boxStartCol, int num)
{
for (int row = 0; row < 3; row++)
for (int col = 0; col < 3; col++)
if (grid[row + boxStartRow]
[col + boxStartCol] ==
num)
return true;
return false;
}
/* Returns a boolean which indicates whether
it will be legal to assign num to the given row, col location. */
bool isSafe(int grid[N][N], int row, int col, int num)
{
/* Check if 'num' is not already placed in
current row, current column
and current 3x3 box */
return !UsedInRow(grid, row, num)
&& !UsedInCol(grid, col, num)
&& !UsedInBox(grid, row - row % 3,
col - col % 3, num)
&& grid[row][col] == UNASSIGNED;
}
/* A utility function to print grid */
void printGrid(int grid[N][N])
{
for (int row = 0; row < N; row++)
{
for (int col = 0; col < N; col++)
cout << grid[row][col] << " ";
cout << endl;
}
}
/* A utility function to print grid in a single row with no space in between*/
void printGrid2(int grid[N][N], char c)
{
for (int row = 0; row < N; row++)
{
for (int col = 0; col < N; col++) {
if ( grid[row][col] == 0 ) {
cout << c;
} else {
cout << grid[row][col];
}
}
}
cout << endl;
}
void initGrid(int grid[N][N])
{
for (int row = 0; row < N; row++)
{
for (int col = 0; col < N; col++) {
grid[row][col] = 0;
}
}
}
void randN(int arr[], int CNT ) {
for(int i =0 ; i < CNT; i++) {
arr[i] = 0;
}
srand((unsigned int) time(NULL));
//random_device rd;
//mt19937 gen(rd());
//uniform_int_distribution<int> dis(1, CNT);
for(int knt = 0; knt < CNT; ) {
int num = (rand() % CNT) + 1;
//int num = (dis(gen) % CNT) + 1;
int flag = 0;
for( int a = 0; a < CNT; a++ ) {
if( arr[a] == num ) {
flag = 1;
break;
}
}
if( flag == 0 ) {
arr[knt++] = num;
}
}
}
void fillBox(int grid[N][N], int row,int col)
{
int knt = 0;
int arr[9];
randN(arr, 9 );
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
grid[row+i][col+j] = arr[knt++];
}
}
}
void fillZeros(int grid[N][N], int grid2[N][N],int CNT) {
int arr[81];
randN(arr, 81);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
grid2[i][j] = grid[i][j];
}
}
for (int i = 0; i < CNT; i++) {
int rn = arr[i];
int row = rn / 9;
int col = rn % 9;
grid2[row][col] = 0;
}
}
int main()
{
// 0 means unassigned cells
int grid[N][N];
int grid2[N][N];
char s[] = ".7.1.3965.9....2.7..67..4..6..5.1....4..8.65171.2..3.9.5..7.1..1....489..32....7.";
int cnt = 0;
int c;
initGrid(grid);
for(int i = 0; i < 81; i++ ) {
c = s[i];
int row = i / 9;
int col = i % 9;
if( s[i] == '.' )
c = '0';
grid[row][col] = c - '0';
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
grid2[i][j] = grid[i][j];
}
}
if (SolveSudoku(grid) == true) {
//fillZeros(grid, grid2, 40);
printGrid(grid2); cout << "\n";
printGrid(grid); cout << "\n";
printGrid2(grid2, '-');
printGrid2(grid, '@');
//printGrid2(grid2, 'X');
} else {
cout << "No solution exists";
}
return 0;
}
/* ************************************************************
s='''
a7a1a3965a9d2a7b67b4b6b5a1d4b8a65171a2b3a9a5b7a1b1d489b32d7a
d5a9c8a79a2d928b754c157a6251a67b4c8a2f6a8c8a3a2a61b67a3b5a
9e2a723b9c15b31a9a6c56a4a3a1d76b691d5752643e3c6b6a8a2c4
16a3fb76b4384e7b216c3a435a71d8b3a75c4d1a3a6a47a95a7b536b
a9b4a58a38c52e78c1a7b68c46b3b72c4c3a859b174a73b5b2a6a4b7b3
4a6e3a37b6a2b9835c6a7b6b41d3a9b3842e619a87e56b1d31a57a4
b38c9b98a354c5a4c23a76a8a1a4e6257a32d6b8e7a7d8b23a514a6a9
1c7923a9a8e757b2c87a2b6b9a8e61691c4a3356712c8b9d2d5a1b
71f6a6b73815853a9f6b94a197d2d8b5a9a18b57b94c21a6b9c8b2
5a39a62c2fa9a7e8a1a3b89c8a5b2b72b96a5a365a89a1a4921a58b51f
b9a1a42a21fb3b529a13c2c6a4a8a53b6b9b2b8a327e573a1a624a1a8c3
b6e3a9b43a277a4b2a5b4e91b3fb17a4a32369a18a7a4185b3c2b3b84
d126b217a8b4b69a7b8c67d84732a85b18d476a2b9b6a9b8e65e91
a567c2d13a7a6317d9872a5b8fa8a1518b4a27c1b7a3b7a8c4a492b1c
5b134b7a4fa6a7c42e1d18c957b5a8a21c9a467f5a36823a5a817a4
859a6a4a7b2a9a5c745816b4a7c8a6a816a4a9b36fb5c3f5a2416b8b9b
e3b5a36a4c85b8a7b34b1b5b89a3a2a4b63594c312c98a95d7a2e93a1
b63287a5a1a54b28a2a9f4c3a7a8c9a64a1b654a329a1a3d3c8a296e9c
d8a5a77c4b86e9b439a4287a1458c3a2c5c9a68a3c1c9761b3e26a9
6b1b278a2c43a69e514a3c7a2b92c7c17a69e4e338a74a15b519b6b
9b2c5a2c98b773d4b5b71936b6a3a5b81a3a6a925b7a42c8b1d96a4d1a
7c36b91a3a9a2a8f53a89b731422fb3c82d1a65a3e219b5a7a34b61
a1c36a2a4a5a9a81a561c79d45a63b2e7b569b2b9f4b49b81a62c47a5
a5f36b4a92d83a1a56e23a59a27a51b5a16a479c75b63fc91a59c27
a32b5d8c3c7a6a9213fa418a24b75a9b1a5b7b935d7d492a1a15678c
b19a6a85a9a4d28a25a7a1b37e428b7a936b9e1f29a4a379a168b6b1c
d2d5a2a694a7a6a8a5a29a75b28a3fa622b67d1a87b5a495c32a6e1a78
b28b9a6a984a5c75a1fd75b23c8a7a6a52b1a34a3b176a5f29a67b284a
12865b9b9b84b3a3a97c6c4b8c4a8a1a79a79a6fc8a347a4a2b1a913a4d
1d5b26b2a3a4b2e16f65a81b46a794a69a2b8a64328a9a58b6b2a9c5d
6a2a9a83a78c39c19f97a2d4a3b54d5d3c9a3a2a674d519a5b9174a8
f7621a79a65a453a7a2a1a4a3b1b56b37a2b8e6a37a8fa496a7d61b3b7
2a43a5f7a23b5a76d4a6a4a8a957d3d48c73a35b6e71a3a6a26a9127c
b92346c3a71a8a4d569b4a2b7c6e7917a3b1a25c46c9c92b73a2a17d
a5c9a4b6c17a881a4b2c4b95d25b6c697a2a81b7f1b4612c581a7a4a2
7b1b69b8b3b52fa179b6b1a55c237d75b28a4358a792c92a6b1b1a9d
b943a2b14c6e82a1c2d453c68b9a4b5a73b2854a2b9b2d417a61b9b5
28c314a34d867fb24b3a765d4819b82a56c4b4a78d1a235b6c69d
f416d68e973c8a4b83b2d7a165a672a1b4a2a9a7a8c13b5a7a3b4a921
8f2e7c47c64b918a7a62a525b4a7b4a6a1d927b3416c6a1b2b54b9a8
d23d19a4c6328c71b93b54b251d3a48b172a9c45b6a16a832c8e1b
a76c5d3a6579c81a962a6c4e8c2b67245e4d1b7a92457a61c62c5
b3fa76a9b2b2a8a71b75d68d27a39a93b6c73b7869a264a1a985a2c5d
29b74a56564c2e6d37d9b8a48567a1b2a8b7d64c89a5c6a24c9a1a3a
8a561a7b2b897b67e1c5c3b1a89c3a73a7b9fb82b9b57a6a357a362b4
7b6a8b114b2b7b8d32f7c91a85a4b8e2a7d7163a6a5a3a9a83c86745
d2a81a3d879a8fa2a69a5c7b7c52c59a2a8454c7a6e394519c852a3
b6b3e47a81a5f74a2b89a53a4783a1b6e2a14a5b36a9c29b671b9b7a5a
4e51c5a2c491b436a2a5a9c311b78b2a86243175e79a6c63fd8b5
b52b3a1127b4b5a3c8c568c43b7d16b41386d9a5a38178c7fb4a2a3
2fe1a8c93d5b3c4a1b51b274b479d35d7a3a2d8c41d5a68
b9a138c85c71c7c2b32b9b54b83d1b6b1c9d8a3e35a72f4b
2fa61d754c8b1b7b3a6a2c52b963a4a63e5f6b3b7e8b1a45a
c1fa1d34b6a7a1c35f2a4b85c8c3b6b9382457c59f87c2a
b7a49a6c6b79f3b5a5a3c6f96c7b351b961c3e2b514fa7a2
a75348c3e8b6e431c4b3d85b9c3c2b5d1c39c85c2e168
b59c1a4a1a3d6c25f3b1a8a1c73b7f9a3c9648c8b35c5a7d3
a3a7a5a64c1a3b27fd5b86b3a6d7d6a13e8a64b8b452c6c9c1
c23a9d6d28a9c6a1b693e13d7fa4e3a59b25b1b46b48b2b3
c2d9b1d2b946fc6d1e3b3c75a12a82d31b9a2a65c5b1278
1c9b76a6c2b353a1b28a4a36b95a97a4fa28ff1f8d9c164a
a7a6214a3a35e7d75fb3b45c6b1c1b89a29b21f65b2d3e6
a389a547b1a6a4b3b4b1e3a7b1b9e6a2c6a3a8b7b6a9b2fa5d27b
fd264a3d8b5a236d7c9b289a54a3a9b1fb4a5b98765d5d1b
c3e52b1b7b1895d3e2c52a4c397a5c6fa9f9a53a6a5a7a41a
a159a8b26491e2c3a6a9b3e7c4e97c5ffa5a7a1e8a49125
a8d2c9a45267a75b9d8a9b7fb9a61c56a4d6e7a4a9d691b3d
a5f2c8e2a9a37a6a94c6f483a5b81c24b2b7b9b7c918a8fa4
f43b7a8fa64718a5a12b7b8d6f59a4b3c5c8b2d1c84b3a52
21c3c7a654a9fa7a43c3c78a9a72d5a7c4b3fa4a7a1f6b98a2a
a7e1a2a69a1b33d6d9c78a1c5a4e4b2a9a6a91a8d1d762d65c
8a2a9b6e8a4b3b2b8c59b2a3fa251c1a79b4d8b77f4b38a79c
fb1a6c8c294a3b8e871b6e2a9a12a6a57a5d4a1a3d674c6c3b
a4a7b13c2c6e42d6d2b3231a7b8a4b31e7c8e6a3c489b5c6
c7e3a19a8e83a219fd8c67a2b2c981c74b538e3b1d2a47a
a79c4b4a2e7b39f9b5d3a4a2a9b75a38a64f8fa9a31c5a437b
a7b3a6a9b3c84b1a7e96a1b7c846ffa4b9b42b2a19564b8fa5
c2b1b84a1a76c9a8a3f51f9e52a8e75a4d2a6e9b9a734b81
b5e8b7b1fa4fa86a92f75a4a9b32a6c42596b51a6c9a6c1a8b
2a6f7b84e8a32fe57a98b2b3a5b9a2a68b4a1d312b7e75c8
82e4a4ffb893b3a7a1b17a46f45b3d13a64c8b9a5a1a461e
398a2fa4a78a347c9a6b49fe3c6b812a5d564b2a1d4e2b5b
a95b8a27fa1f4c7a84d5a1c3a9c9a2a84a2a4a951c7c2f341c
b97b2d5e124c5a9b3d1c2a9a783e4c95a4e3c8a941d6b5a2
b3a8c7c1a6e8a9b163c6a4b14a83a7c7ff9a7386b7f1a289b
d2b4a3d917d67a8f18392b35b7fa7a868fc1a7a49c97d3a
4d715a1758a3fa4a97b4fb6a371a94fd21c34a6c3d7a86e
a3c2b4c7a495d6c3c43b6c8a5d73b9b84a5c7a4a3d6e19c52a
4d8a1a6c9c7a754a6f6f1a5d85c13fd2586a25c99a2a4b3a
5e9d1a95a8b4a7a1fe2c12b96e8153a8d61d3e6a98a253a
9b2d34a689b5b5b34a9a5234d6a7fa1a9b2fa15a6fb8976fa
a1f4e5a1d4918a27b6c2f4b3b13b9a65a8a692d7d3d543c
a1d45d5a9a72b3f36f742b8a13a1e9a89c7d6b3a5f46a8a3
d24b751d62a247c3a59d62e3a7d76b9c7c1b8c14a5d9b7d
6a8f3a7b2b5a429b8a6c1a7fd4a52b8a1a99b5a8a2a2b3a4d1b2d
a5d8fa73b4d6a95a8a2b451e9e618b3b4b9b1a3fa9b9a3528a
c5fb39c7d714c4a8b2a1a8d5a9a6a12a8b4c563b37fa6b4c58
3a67b98fd8c96c9e1c82b5b9b59a3b2d5c8a1c73c3b6147a
b7c4a23c6a8d8d7a7d8591a4b7d8a2a5b4b3a5b9a84a59fe3a4
b82c6b294b8b7a4a9d1a6a7c8e37a28c4a6b2d1a8fc66a1c45a
a2c7d1fc9c52e51a6d6c3d3a4b5b84b6d7d41a65a9d
3b2f4a5fb4b3985a1fe9a74e1c4e65b7e2c9a76b3
b71b9a2b6c7c9fa82b3fb79a3fc437b64a1fa2d4b1a9a
63e1d3a1fa46a751a248b6e9a4ffa5d8f37c8d1a4
a2b5b3b3c7fa4c24a1a8a57b8e1ff5a73a9e2a4a1c9a8c
b48f3a1a9b8d2b5b8b5a9d634a1fffa56a5c2c7b6b49
e24f3a5c6e8e15e9a2b5a7a3d6c6b31b3b2d45a1e9
c9f64a12b8a2d96313a7d4ffa9a75247e2f8fa6d
c6e2b3b9c87fa64b5b7e2a315fd62c8a3b9c1c9a7b6a
e654a48a1fa14e83e7c5a9b26b96e1f6e731c2fa
a4f3a9a6e27d51c34a6a8fb7d8a5b1a6fe1b5298d3b
b46a782b6ff2e716d29d4a1fb34e3a83d5a9f36b
b7fb59a3b7a9a7fd68e2b96b5b3fb8a4b48a1b2b23f5
75f3c4fc29b78c3a9c9c2e67b8b6a23a7e1fb9b6b1
789c5c5c4fa3d3c9b6b2b5b81e1a9a4b6c1a87c2fc9b
d9e61c9d7d45a9f6a3a4a78f6a21f573f8c65b2d
1a9b4c5c1f2b35b8c42a1f7a9fc3a75e2b89c6fb47
a8b4c1c85a6a22a3fb6d2a49c7f6c85b25d6a1ffa9a4
1b3e3c798a2d8a9a4e1a2fa4d65a7d48c2fb7a9a3a8e
9c5a1d6b3c2fe7b5c7b1c9b4b6b3a1b2d6e93b4a9c75
b8b6e1e3a5b4a27fc74fa5c875b2b9b784e62d1b5d
d9d96c18fa2a5b3a4a9b2d2a4c2e17f69c4f713a4d
e3c516a47fb6e4c78a36c95e2d369f1a2a5c4fb3a
8a2637c9b2e65fb9a7c4c1f7a59a8fa1d4c6b7fa6a3
e52c1a6a4c9f7c536c4a761fa3a4a1ff57d21f7a9
b1a7b2d5a38c2f5b9fa379fb6b24f4a5c2e19d6a74
5a1a6fc5b6a6984e54c71f2b5a8fa2d1d9c837f3c
2b1a9c4e3b1f46e4f7b92b5c1a8d4c6c4a3a5c2b8c9
a5b6a4d82fc3498a9e7c258fc43e9d7a3e69f23b
d1a97b42b8b1c3fd1fb78b8a6b9b5a2b64a9fb5c92b7b
a7d8e423a7b32d54a2b8b9f9e1b4b7a9a6e4fe7b1a8
e7a1d43f15b2c3d6a8b8fa2a7d576e434a3c8f1a5b
d4a2c8b6b9a7a5b3a1b6b9fe78d15e8b1c69b5c2a7a3e
fc81a64f28c4b47d25e5b6b1a9fb6a8b5d37d9b74b
1d6e8c5a4a9e3d9b8c32c6b6e21f3b8b75b9f4b57
a7b5c36c8a4c1b74b576fa5a4b92fa2fb8fc9c4b36b7
17c4b6a8e2a3fa5e2c94a8e7b56a1b8e39f3d9a2c5a
d6a3d3c4a851b4c6a5a916a2a2fc49fa34c9c9a5c1fd
b4613fe9a1b5c3b7fd9b5b8a7a26e53b84b2e793fa
a7d6a9b92d5a3a78c2d13e4fa5a8e6c4f23a74fc96
a6e9a5a8a6b7a3b19e1c2a8a6a4b5fe14b3fa2a4d9e75a
a9a12d5f2a6d4e4a1a2c867fd8a5a92c35c1b4a3f7d
a65d71e78e8c6c9a2a64d6b1a2b1fd7fa9a4b7a1d2a5
c3a1a56b9a8c47fd49f9b3b8a153a4d5e6e4b1fb7a9
a74c2f1e3d4a7c6b82a15b3c9b32c5a9fd7549fd8a
a341b9fc75e6c95e8d69b1c7c42c1d976b2fd5b1
e82b8b9e3a4c8f3a7b9b5e1fa6b261b4c6d2c83c15
a4a3fa96a8a158ffa71d1a4a8b583fa1b6fd7c6a4a9b3
a1f4a3b6c9a245d3fb246fd9a48d5a2b1d658d9d6b
b64a3a19e1b6a8d2e269b75f2c9d4b2a5e1b8fc1b7a
'''
def func1( itm ) :
for c in itm:
if c == 'a' or c == 'b' or c == 'c' or c == 'd' or c == 'e' or c == 'f' :
n = ord(c )- ord('a') + 1
for i in range(n):
print('.', end='')
else:
print(c, end='')
print('\n')
t = s.split('\n')
for itm in t:
if len(itm) < 1:
print( '###########################################################' )
continue
func1( itm )
************************************************************ */'C++ 언어' 카테고리의 다른 글
| C++ 에는 split 이 없다 (0) | 2021.10.26 |
|---|---|
| VM 만드는 방법 (2) | 2021.09.27 |
| C++, 텍스트 파일의 빈 줄 지우는 프로그램 (1) | 2021.09.24 |
| C++를 이용 JSON을 SRT 파일로 만들기 (1) | 2021.09.11 |
| C++에서 Vector를 사용하여 문자열 정력하기(중복테이타 제외) (0) | 2021.09.10 |
댓글