fork download
copy 
  1. #include <iostream>
  2. #include <cmath>
  3. #include <string>
  4. #include <vector>
  5. using namespace std;
  6.  
  7. int origAA[28];
  8. const int ROWS = 25;
  9. const int COLS = 25;
  10.  
  11. // 1. PEDIR LINK AL USUARIO:
  12. string pedirLinkUsuario() {
  13.     string entrada;
  14.     cout << "Por favor, ingresa el link a codificar: ";
  15.     cin >> entrada;
  16.     return entrada;
  17. }
  18.  
  19. // 2. LINK A BINARIO:
  20. // Conversión Entero a binario 
  21. void decimalABinario(vector<int>& listaBits, int valorDecimal, int cantidadBits) {
  22.     // Se recorre desde el bit más significativo hacia abajo
  23.     for (int i = cantidadBits - 1; i >= 0; --i) {
  24.         int bit = (valorDecimal >> i) & 1; 
  25.         listaBits.push_back(bit);
  26.     }
  27. }
  28.  
  29. // Función Binario a Decimal (longitud)
  30. int binarioADecimal(const vector<int>& bits) {
  31.     int valorDecimal = 0;
  32.     int potencia = 1; // Empezamos con 2^0 = 1
  33.     // Recorre el vector de atrás hacia adelante
  34.     for (int i = bits.size() - 1; i >= 0; --i) {
  35.         if (bits[i] == 1) {
  36.             valorDecimal += potencia;
  37.         }
  38.         potencia *= 2; // La potencia se duplica en cada paso (1, 2, 4, 8...)
  39.     }
  40.     return valorDecimal;
  41. }
  42.  
  43. vector<int> procesarLink(string linkUsuario) {
  44.     vector<int> listaBits;
  45.  
  46.     // A. MODO DE CODIFICACIÓN Binario (0100)
  47.     decimalABinario(listaBits, 4, 4); 
  48.  
  49.     // B. INDICADOR DE LONGITUD (8 bits)
  50.     int cantidadLetras = linkUsuario.length();
  51.     decimalABinario(listaBits, cantidadLetras, 8);
  52.  
  53.     // C. TRADUCCIÓN DE DATOS (ASCII a Binario)
  54.     // Recorre el link letra por letra y convertimos su valor ASCII a 8 bits.
  55.     for (int i = 0; i < cantidadLetras; ++i) {
  56.         char letra = linkUsuario[i];
  57.         decimalABinario(listaBits, letra, 8);
  58.     }
  59.  
  60.     // D. TERMINACIÓN Y ALINEACIÓN
  61.     // 224 bits (28 bytes).
  62.     int capacidadTotalBits = 224; 
  63.     int bitsUsados = (int)listaBits.size();
  64.     int espacioLibre = capacidadTotalBits - bitsUsados;
  65.  
  66.     // A) Terminación (0000)
  67.     if (espacioLibre >= 4) {
  68.         decimalABinario(listaBits, 0, 4);
  69.     } else if (espacioLibre > 0) {
  70.         decimalABinario(listaBits, 0, espacioLibre);
  71.     }
  72.  
  73.     // B) Alineación a Byte (Total de bits = múltiplo de 8)
  74.     while (listaBits.size() % 8 != 0) {
  75.         listaBits.push_back(0);
  76.     }
  77.  
  78.     // E. RELLENO (PADDING BYTES)
  79.     // Si sobran bytes vacíos, se rellenan alternando 236 (11101100) y 17 (00010001)
  80.     int byteRelleno1 = 236; // 11101100
  81.     int byteRelleno2 = 17;  // 00010001
  82.     bool usarPrimerByte = true;
  83.  
  84.     while (listaBits.size() < 224) { 
  85.         if (usarPrimerByte) {
  86.             decimalABinario(listaBits, byteRelleno1, 8);
  87.         } else {
  88.             decimalABinario(listaBits, byteRelleno2, 8);
  89.         }
  90.         // Cambiamos el turno para el siguiente byte
  91.         usarPrimerByte = !usarPrimerByte;
  92.     }
  93.  
  94.     return listaBits;
  95. }
  96.  
  97. // 3. MOSTRAR VECTOR RESULTANTE
  98. void mostrarVectorBits(const vector<int>& bits) {
  99.     cout << "\n---------------------------------------------------------------------" << endl;
  100.     cout << "----------------------------VECTOR DE BITS---------------------------" << endl;
  101.     cout << "---------------------------------------------------------------------\n"<< endl;
  102.  
  103.     int contador = 0;
  104.     for(int i = 0; i < bits.size(); ++i) {
  105.         cout << bits[i];
  106.         // Formato visual: espacio cada 8 bits (1 byte)
  107.         contador++;
  108.         if (contador % 8 == 0) cout << " "; 
  109.         if (contador % 64 == 0) cout << endl; // Salto de línea cada 64 bits
  110.     }
  111.     cout << endl << endl;
  112. }
  113.  
  114. //Convertir un dato de binario a decimal
  115. int binario_Decimal(string a){
  116.     int resultado = 0;
  117.     for (int i = 0; i < 8; i++) {
  118.         resultado = resultado * 2;
  119.         if (a[i] == '1')
  120.             resultado += 1;
  121.     }
  122.     return resultado;
  123. }
  124.  
  125. //Convertir un dato de decimal a binario
  126. string decimal_Binario(int a){
  127.     string bin = "00000000";
  128.     for (int i = 7; i >= 0; i--) {
  129.         bin[i] = (a % 2) + '0';
  130.         a /= 2;
  131.     }
  132.     return bin;
  133. }
  134.  
  135. //Formar el vector en decimal para la correcion
  136. void VectorParaCorreccion(vector<int>& vectorbits){
  137.     int indice = 0;
  138.     string cadena="";
  139.     string origBinario[28];
  140.  
  141.     for (int i = 0; i < 224; i++){
  142.         cadena += to_string(vectorbits[i]);
  143.     }
  144.  
  145.     for (size_t i = 0; i < cadena.size(); i += 8) {
  146.         origBinario[indice] = cadena.substr(i, 8);
  147.         origAA[indice]=binario_Decimal(origBinario[indice]);
  148.         indice++;
  149.     }
  150. }
  151.  
  152. //Multiplicar dos datos en MG
  153. int M_GF(int a, int b){
  154.     int multiplicacionAA;
  155.     int pol = 285;
  156.     int grande;
  157.  
  158.     multiplicacionAA = 0;
  159.     for (int i = 0; i < 8; i++) {
  160.         if (b % 2 == 1){
  161.             multiplicacionAA = multiplicacionAA ^ a;
  162.         }
  163.         grande = (a >= 128);
  164.         a = a * 2;
  165.         if (grande){
  166.             a = a ^ pol;
  167.         }
  168.         a = a & 255;
  169.         b = b / 2;
  170.     }
  171.     return multiplicacionAA;
  172. }
  173.  
  174. //Correcion y formar vector para acomodar
  175. vector<string> RS(){
  176.     vector<string> VectorParaAcomodar(45);
  177.     int VectorRsD[16];
  178.     int multiplicacionAA;
  179.     int c, a, b, contador = 0, contador2 = 0;
  180.     int generador[17] = {1, 59, 13, 104, 189, 68, 209, 30, 8, 163, 65, 41, 229, 98, 50, 36, 59};
  181.     int junto[44];
  182.  
  183.     for (int i = 0; i < 44; i++){
  184.         if (i < 28){
  185.             junto[i] = origAA[i];
  186.         }
  187.         if (i >= 28){
  188.             junto[i] = 0;
  189.         }
  190.     }
  191.  
  192.     for (int i = 0; i < 28; i++) {
  193.         c = junto[i];
  194.         if (c != 0){
  195.             for (int j = 0; j < 17; j++) {
  196.                 a = generador[j];
  197.                 b = c;
  198.                 multiplicacionAA = M_GF(a, b);
  199.                 junto[i + j] = junto[i + j] ^ multiplicacionAA;
  200.             }
  201.         }
  202.     }
  203.     for (int i = 28; i < 44; i++){
  204.         VectorRsD[contador] = junto[i];
  205.         contador += 1;
  206.     }
  207.  
  208.     for (int i = 0; i < 45; i++){
  209.         if (i<28){
  210.             VectorParaAcomodar[i] = decimal_Binario(origAA[i]);
  211.         }
  212.         if ((i >= 28) && (i < 44)){
  213.             VectorParaAcomodar[i] = decimal_Binario(VectorRsD[contador2]);
  214.             contador2 ++;
  215.         }
  216.         if (i==44){
  217.             VectorParaAcomodar[i] = "0000000";
  218.         }
  219.     } 
  220.     return VectorParaAcomodar;
  221. }
  222.  
  223. /*
  224. Blanco = 2
  225.  
  226. Negro = 3
  227.  
  228. Amarillo = 4
  229.  
  230. Azul = 5
  231.  
  232. Vacío = 9
  233. */
  234. void inicializarMatriz(int matriz[ROWS][COLS]) {
  235. 	for (int i = 0; i < ROWS; ++i){
  236. 		for (int j = 0; j < COLS; ++j){
  237. 				matriz[i][j] = 9;
  238. 		}
  239.  
  240. 	}
  241.  
  242. }
  243.  
  244.  
  245. // Dibuja un cuadro grande de posicionamiento 7x7 con borde blanco de 1 celda
  246. void dibujarFinder(int matriz[ROWS][COLS], int top, int left) {
  247. 	const int size = 7;
  248.  
  249.     // Perímetro blanco (2)
  250.     for (int dy = -1; dy <= size; ++dy) {
  251.         for (int dx = -1; dx <= size; ++dx) {
  252.             int y = top + dy;
  253.             int x = left + dx;
  254.  
  255.             if (y >= 0 && y < ROWS && x >= 0 && x < COLS) {
  256.                 matriz[y][x] = 2;
  257.             }
  258.         }
  259.     }
  260.  
  261.     // 7x7 negro (3)
  262.     for (int dy = 0; dy < size; ++dy) {
  263.         for (int dx = 0; dx < size; ++dx) {
  264.             matriz[top + dy][left + dx] = 3;
  265.         }
  266.     }
  267.  
  268.     // 5x5 blanco interior (2)
  269.     for (int dy = 1; dy < size - 1; ++dy) {
  270.         for (int dx = 1; dx < size - 1; ++dx) {
  271.             matriz[top + dy][left + dx] = 2;
  272.         }
  273.     }
  274.  
  275.     // 3x3 central negro (3)
  276.     for (int dy = 2; dy < size - 2; ++dy) {
  277.         for (int dx = 2; dx < size - 2; ++dx) {
  278.             matriz[top + dy][left + dx] = 3;
  279.         }
  280.     }
  281. }
  282.  
  283. // Cuadro pequeño de alineación 5x5
  284. void dibujarAlignment(int matriz[ROWS][COLS], int top, int left) {
  285. 	const int size = 3;
  286.  
  287.     left += 1;
  288.     top += 1;
  289.  
  290.     // Perímetro negro (3)
  291.     for (int dy = -1; dy <= size; ++dy) {
  292.         for (int dx = -1; dx <= size; ++dx) {
  293.             int y = top + dy;
  294.             int x = left + dx;
  295.  
  296.             if (y >= 0 && y < ROWS && x >= 0 && x < COLS) {
  297.                 matriz[y][x] = 3;
  298.             }
  299.         }
  300.     }
  301.  
  302.     // Cuadro 3×3 blanco
  303.     for (int dy = 0; dy < size; ++dy) {
  304.         for (int dx = 0; dx < size; ++dx) {
  305.             matriz[top + dy][left + dx] = 2;
  306.         }
  307.     }
  308.  
  309.     // Interior 1×1 negro
  310.     matriz[top + 1][left + 1] = 3;
  311.  
  312.  
  313. }
  314.  
  315. // Coloca los cuadros grandes (UL, UR, LL)
  316. void colocarFinders(int matriz[ROWS][COLS]) {
  317. 	const int size = 7;
  318.  
  319. 	dibujarFinder(matriz, 0, 0);                    // Superior izquierda
  320. 	dibujarFinder(matriz, 0, COLS - size);          // Superior derecha
  321. 	dibujarFinder(matriz, ROWS - size, 0);          // Inferior izquierda
  322.  
  323. }
  324.  
  325. // dibuja las lineas de sincronizacion
  326. void dibujarTimingPatterns(int matriz[ROWS][COLS]) {
  327. 	int start = 8;
  328.     int end = COLS - 9;
  329.  
  330.     // horizontal (linea 6)
  331.     int row = 6;
  332.     for (int j = start; j <= end; ++j) {
  333.         if ((j - start) % 2 == 0) {
  334.             matriz[row][j] = 3;
  335.         } else {
  336.             matriz[row][j] = 2;
  337.         }
  338.     }
  339.  
  340.     // vertical (columna 6)
  341.     int col = 6;
  342.     for (int i = start; i <= end; ++i) {
  343.         if ((i - start) % 2 == 0) {
  344.             matriz[i][col] = 3;
  345.         } else {
  346.             matriz[i][col] = 2;
  347.         }
  348.     }
  349.  
  350. }
  351.  
  352. // reserva las zonas de formato para que nadie escriba encima
  353. void reservarZonasFormato(int matriz[ROWS][COLS]) {
  354.     // zona primaria - columna 8 (filas 0-8 excepto 6)
  355.     for (int i = 0; i <= 8; ++i) {
  356.         if (i != 6) {
  357.             matriz[i][8] = 6;
  358.         }
  359.     }
  360.     // zona primaria - fila 8 (columnas 0-8 excepto 6)
  361.     for (int j = 0; j <= 8; ++j) {
  362.         if (j != 6) {
  363.             matriz[8][j] = 6;
  364.         }
  365.     }
  366.  
  367.     // zona secundaria inferior - columna 8 (filas 17-24)
  368.     for (int i = 17; i <= 24; ++i) {
  369.         matriz[i][8] = 6;
  370.     }
  371.  
  372.     // zona secundaria derecha - fila 8 (columnas 17-24)
  373.     for (int j = 17; j <= 24; ++j) {
  374.         matriz[8][j] = 6;
  375.     }
  376.  
  377.     // dark module siempre negro
  378.     matriz[17][8] = 6;
  379. }
  380.  
  381. // rellena las zonas de formato con los bits correctos
  382. // version 2 m mask 0 -> 101010000010010
  383. void colocarFormato(int matriz[ROWS][COLS]) {
  384.     // bits clonados en dos lugares
  385.     int formatoBits[15] = {1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0};
  386.  
  387.     // ubicacion primaria (alrededor del finder superior izquierdo)
  388.     // primero: columna 8, filas 0-5, luego fila 7, luego fila 8
  389.     matriz[0][8] = formatoBits[0];
  390.     matriz[1][8] = formatoBits[1];
  391.     matriz[2][8] = formatoBits[2];
  392.     matriz[3][8] = formatoBits[3];
  393.     matriz[4][8] = formatoBits[4];
  394.     matriz[5][8] = formatoBits[5];
  395.     // saltar fila 6
  396.     matriz[7][8] = formatoBits[6];
  397.     matriz[8][8] = formatoBits[7];
  398.  
  399.     // segundo: fila 8, columnas 7, 5, 4, 3, 2, 1, 0
  400.     matriz[8][7] = formatoBits[8];
  401.     // saltar columna 6
  402.     matriz[8][5] = formatoBits[9];
  403.     matriz[8][4] = formatoBits[10];
  404.     matriz[8][3] = formatoBits[11];
  405.     matriz[8][2] = formatoBits[12];
  406.     matriz[8][1] = formatoBits[13];
  407.     matriz[8][0] = formatoBits[14];
  408.  
  409.     // ubicacion secundaria (lado contrario)
  410.     // columna 8, filas desde abajo (24..18)
  411.     matriz[24][8] = formatoBits[0];
  412.     matriz[23][8] = formatoBits[1];
  413.     matriz[22][8] = formatoBits[2];
  414.     matriz[21][8] = formatoBits[3];
  415.     matriz[20][8] = formatoBits[4];
  416.     matriz[19][8] = formatoBits[5];
  417.     matriz[18][8] = formatoBits[6];
  418.     // dark module (17,8) siempre negro
  419.     matriz[17][8] = 1;
  420.  
  421.     // fila 8, columnas desde la derecha (17..24)
  422.     matriz[8][17] = formatoBits[7];
  423.     matriz[8][18] = formatoBits[8];
  424.     matriz[8][19] = formatoBits[9];
  425.     matriz[8][20] = formatoBits[10];
  426.     matriz[8][21] = formatoBits[11];
  427.     matriz[8][22] = formatoBits[12];
  428.     matriz[8][23] = formatoBits[13];
  429.     matriz[8][24] = formatoBits[14];
  430. }
  431.  
  432. // Muestra el QR (símbolos distintos para poder distinguir en consola)
  433.  
  434. void mostrarMatriz(int matriz[ROWS][COLS]) {
  435. 	// CARACTERES
  436.     for (int i = 0; i < ROWS; ++i) {
  437.         for (int j = 0; j < COLS; ++j) {
  438.  
  439.             switch (matriz[i][j]) {
  440.                 case 2: {
  441.                 	cout << char(219) << char(219);
  442.  
  443.                     break;
  444.                 }
  445.                 case 3: {
  446.                     cout << "  ";
  447.                     break;
  448.                 }
  449.                 case 4: {
  450.                     cout << "::";
  451.                     break;
  452.                 }
  453.                 case 5: {
  454.                     cout << "@@";
  455.                     break;
  456.                 }
  457.                 case 9: {
  458.                     cout << "##";
  459.                     break;
  460.                 }
  461.                 default: {
  462.                     cout << "??";
  463.                     break;
  464.                 }
  465.             }
  466.         }
  467.         cout << "\n";
  468.     }
  469.  
  470.     cout << "\n\n";
  471.  
  472.     // VALORES MATRIZ
  473.     for (int i = 0; i < ROWS; ++i) {
  474.  
  475.         for (int j = 0; j < COLS; ++j) {
  476.             int valor = matriz[i][j];
  477.  
  478.             // revisar si esta en zona fija
  479.             bool esZonaFija = false;
  480.  
  481.             // timing patterns
  482.             if (i == 6 || j == 6) {
  483.                 esZonaFija = true;
  484.             }
  485.             // finder patterns y separadores
  486.             if ((i <= 8 && j <= 8) || (i <= 8 && j >= 17) || (i >= 17 && j <= 8)) {
  487.                 esZonaFija = true;
  488.             }
  489.             // alignment pattern (16-20, 16-20)
  490.             if (i >= 16 && i <= 20 && j >= 16 && j <= 20) {
  491.                 esZonaFija = true;
  492.             }
  493.  
  494.             // aplicar mascara 000 solo a datos
  495.             if (!esZonaFija && (valor == 0 || valor == 1) && ((i + j) % 2 == 0)) {
  496.                 valor = valor ^ 1; // Invertir el bit
  497.             }
  498.  
  499.             // mostrar cuadros blancos y negros
  500.             if (valor == 0 || valor == 2) {
  501.                 cout << "  "; // Blanco
  502.             } else if (valor == 1 || valor == 3) {
  503.                 cout << char(219) << char(219); // Negro
  504.             } else {
  505.                 // cualquier otro valor lo dejamos blanco
  506.                 cout << "  ";
  507.             }
  508.         }
  509.  
  510.         cout << "\n";
  511.     }
  512. }
  513.  
  514. // Une todos los bytes del vector en una sola cadena de bits
  515. string unirBits(const vector<string>& VectorParaAcomodar) {
  516.     string bits;
  517.     for (const string& byteStr : VectorParaAcomodar) {
  518.         bits += byteStr;  
  519.     }
  520.     return bits;
  521. }
  522.  
  523. void acomodarEnMatriz(const string& bits, int matriz[ROWS][COLS]) {
  524.     int idx = 0;                 // indice del bit actual
  525.     int col = COLS - 1;          // para empezar en la ultima columna 
  526.     bool haciaArriba = true;     // direccion inicial (de abajo hacia arriba)
  527.  
  528.     while (col > 0 && idx < (int)bits.size()) {
  529.  
  530.         if (col == 6) col--;     // saltar columna de timing vertical
  531.  
  532.         int c1 = col;
  533.         int c2 = col - 1;
  534.  
  535.         if (haciaArriba) {
  536.             for (int fila = ROWS - 1; fila >= 0 && idx < (int)bits.size(); --fila) {
  537.                 if (fila == 6) continue; // saltar linea de timing horizontal
  538.                 for (int c : {c1, c2}) {
  539.                     if (c < 0) continue;
  540.                     if (c == 6) continue; // saltar columna de timing vertical
  541.                     // solo colocar datos en celdas vacias (9)
  542.                     // no tocar: finders (2,3), timing (2,3), alignment (2,3), formato (6)
  543.                     if (matriz[fila][c] == 9) {
  544.                         matriz[fila][c] = (bits[idx] == '1') ? 1 : 0;
  545.                         idx++;
  546.                         if (idx >= (int)bits.size()) break;
  547.                     }
  548.                 }
  549.             }
  550.         } else {
  551.             for (int fila = 0; fila < ROWS && idx < (int)bits.size(); ++fila) {
  552.                 if (fila == 6) continue; // saltar linea de timing horizontal
  553.                 for (int c : {c1, c2}) {
  554.                     if (c < 0) continue;
  555.                     if (c == 6) continue; // saltar columna de timing vertical
  556.                     // solo colocar datos en celdas vacias (9)
  557.                     // no tocar: finders (2,3), timing (2,3), alignment (2,3), formato (6)
  558.                     if (matriz[fila][c] == 9) {
  559.                         matriz[fila][c] = (bits[idx] == '1') ? 1 : 0;
  560.                         idx++;
  561.                         if (idx >= (int)bits.size()) break;
  562.                     }
  563.                 }
  564.             }
  565.         }
  566.  
  567.         col -= 2;
  568.         haciaArriba = !haciaArriba;
  569.     }
  570. }
  571.  
  572. int main() {
  573. string linkUsuario = pedirLinkUsuario();
  574. vector<int> bitsFinales = procesarLink(linkUsuario);
  575. mostrarVectorBits(bitsFinales);
  576.  
  577. VectorParaCorreccion(bitsFinales);
  578. vector<string> VectorParaAcomodar = RS();
  579.  
  580. static int matriz[ROWS][COLS];
  581. inicializarMatriz(matriz);
  582.  
  583. colocarFinders(matriz);
  584. dibujarAlignment(matriz, ROWS - 9, COLS - 9);
  585. dibujarTimingPatterns(matriz);  // dibujar timing antes de colocar datos
  586. reservarZonasFormato(matriz);   // reservar zonas de formato
  587.  
  588. string bitsAcomodar = unirBits(VectorParaAcomodar);
  589. acomodarEnMatriz(bitsAcomodar, matriz);
  590.  
  591. // colocar formato al final (pisar los marcadores)
  592. colocarFormato(matriz);
  593.  
  594. // volver a dibujar los timing por si alguien los piso
  595. dibujarTimingPatterns(matriz);
  596.  
  597. mostrarMatriz(matriz);
  598. return 0;
  599.  
  600. }
Success #stdin #stdout 0.01s 5288KB
comments (?)
stdin
copy 
45
stdout
copy 
Por favor, ingresa el link a codificar: 
---------------------------------------------------------------------
----------------------------VECTOR DE BITS---------------------------
---------------------------------------------------------------------

01000000 00100011 01000011 01010000 11101100 00010001 11101100 00010001 
11101100 00010001 11101100 00010001 11101100 00010001 11101100 00010001 
11101100 00010001 11101100 00010001 11101100 00010001 11101100 00010001 
11101100 00010001 11101100 00010001 

              ��??????????????????��              
  ����������  ��??????????????????��  ����������  
  ��      ��  ��??????????????????��  ��      ��  
  ��      ��  ��??????????????????��  ��      ��  
  ��      ��  ��??????????????????��  ��      ��  
  ����������  ��??????????????????��  ����������  
              ��  ��  ��  ��  ��  ��              
����������������??????????????????����������������
????????????  ????????????????????????????????????
????????????��????????????????????????????????????
????????????  ????????????????????????????????????
????????????��????????????????????????????????????
????????????  ????????????????????????????????????
????????????��????????????????????????????????????
????????????  ????????????????????????????????????
????????????��????????????????????????????????????
????????????  ??????????????????          ????????
����������������????????????????  ������  ????????
              ��????????????????  ��  ��  ????????
  ����������  ��????????????????  ������  ????????
  ��      ��  ��????????????????          ????????
  ��      ��  ��??????????????????????????????????
  ��      ��  ��??????????????????????????????????
  ����������  ��??????????????????????????????????
              ��??????????????????????????????????


��������������  ��    ��    ��      ��������������
��          ��    ����    ��        ��          ��
��  ������  ��  ��������      ��    ��  ������  ��
��  ������  ��    ��      ��    ��  ��  ������  ��
��  ������  ��  ��      ����    ��  ��  ������  ��
��          ��      ��      ������  ��          ��
��������������  ��  ��  ��  ��  ��  ��������������
                      ��      ��                  
  ��    ��  ��    ����          ��      ��    ��  
      ��  ��  ��          ��  ������    ��  ����  
    ��  ��  ��  ��  ��      ������  ��          ��
        ����    ����  ��  ����  ��      ��  ��    
            ��    ������    ����    ������  ������
  ������  ��  ����  ����    ����      ��  ��    ��
��    ����  ��    ����    ��      ��  ��������  ��
  ��                ����      ��  ������  ��  ��  
��    ��    ����  ����  ��      ������������������
                ������������  ����      ��  ��  ��
��������������    ��  ����  ��  ��  ��  ��      ��
��          ��    ��    ������  ��      ��  ������
��  ������  ��  ����  ��    ��������������  ��  ��
��  ������  ��      ����    ������  ����  ��  ��  
��  ������  ��  ��  ��    ��  ��    ����  ����  ��
��          ��      ����          ��  ������  ��  
��������������  ��      ��      ��������  ��������
https://ideone.com/EUSsdL
language:
C++14 (gcc 8.3)
created:
10 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!