[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 1.

[Assistant]
```cpp
#include <iostream>
int main() {
    std::cout << 1 << "\n";
    return 0;
}
```

Impresión de literal entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa en C++ que imprima hola en una línea.

[Assistant]
```cpp
#include <iostream>
int main() {
    std::cout << "hola\n";
    return 0;
}
```

Programa mínimo con iostream y cout.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Build a std::vector with push_back for [7, 8, 9, 10] and print the last element.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v;
    v.push_back(7);
    v.push_back(8);
    v.push_back(9);
    v.push_back(10);
    std::cout << v.back() << "\n";
    return 0;
}
```

push_back and back from vector.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Build a std::vector with push_back for [5] and print the last element.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v;
    v.push_back(5);
    std::cout << v.back() << "\n";
    return 0;
}
```

push_back and back from vector.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Print the first two characters of the string "cpp" using substr.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "cpp";
    std::cout << s.substr(0, 2) << "\n";
    return 0;
}
```

string::substr.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Using std::string, store "stl" and print its length.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "stl";
    std::cout << s.size() << "\n";
    return 0;
}
```

string::size / length.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Usando std::vector, crea un vector con {5} e imprime su size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v{5};
    std::cout << v.size() << "\n";
    return 0;
}
```

vector + size desde la librería estándar.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Con std::string, guarda "hola" e imprime su longitud.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "hola";
    std::cout << s.size() << "\n";
    return 0;
}
```

string::size / length.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea un std::map string->int con {"a":1,"b":2} e imprime count("a").

[Assistant]
```cpp
#include <iostream>
#include <map>
#include <string>
int main() {
    std::map<std::string, int> m{{{"a", 1}, {"b", 2}}};
    std::cout << m.count("a") << "\n";
    return 0;
}
```

map::count.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Print the first two characters of the string "ubuntu" using substr.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "ubuntu";
    std::cout << s.substr(0, 2) << "\n";
    return 0;
}
```

string::substr.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Using std::string, store "cpp" and print its length.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "cpp";
    std::cout << s.size() << "\n";
    return 0;
}
```

string::size / length.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Con std::string, guarda "ubuntu" e imprime su longitud.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "ubuntu";
    std::cout << s.size() << "\n";
    return 0;
}
```

string::size / length.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Print the first two characters of the string "qwen" using substr.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "qwen";
    std::cout << s.substr(0, 2) << "\n";
    return 0;
}
```

string::substr.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Print the first two characters of the string "stl" using substr.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "stl";
    std::cout << s.substr(0, 2) << "\n";
    return 0;
}
```

string::substr.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Build a std::vector with push_back for [0, 1] and print the last element.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v;
    v.push_back(0);
    v.push_back(1);
    std::cout << v.back() << "\n";
    return 0;
}
```

push_back and back from vector.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Usando std::vector, crea un vector con {0, 1} e imprime su size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v{0, 1};
    std::cout << v.size() << "\n";
    return 0;
}
```

vector + size desde la librería estándar.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Build a std::vector with push_back for [10, 20] and print the last element.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v;
    v.push_back(10);
    v.push_back(20);
    std::cout << v.back() << "\n";
    return 0;
}
```

push_back and back from vector.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Usando std::vector, crea un vector con {7, 8, 9, 10} e imprime su size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v{7, 8, 9, 10};
    std::cout << v.size() << "\n";
    return 0;
}
```

vector + size desde la librería estándar.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Usando std::vector, crea un vector con {10, 20} e imprime su size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v{10, 20};
    std::cout << v.size() << "\n";
    return 0;
}
```

vector + size desde la librería estándar.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Usando std::vector, crea un vector con {1, 2, 3} e imprime su size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v{1, 2, 3};
    std::cout << v.size() << "\n";
    return 0;
}
```

vector + size desde la librería estándar.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Build a std::vector with push_back for [1, 2, 3] and print the last element.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main() {
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    std::cout << v.back() << "\n";
    return 0;
}
```

push_back and back from vector.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Print the first two characters of the string "hola" using substr.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "hola";
    std::cout << s.substr(0, 2) << "\n";
    return 0;
}
```

string::substr.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Con std::string, guarda "qwen" e imprime su longitud.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main() {
    std::string s = "qwen";
    std::cout << s.size() << "\n";
    return 0;
}
```

string::size / length.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Suma los elementos de {1, 2, 3, 4} con std::accumulate e imprime el total.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <numeric>
int main() {
    std::vector<int> v{1, 2, 3, 4};
    int s = std::accumulate(v.begin(), v.end(), 0);
    std::cout << s << "\n";
    return 0;
}
```

numeric::accumulate.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Use std::find to check if 8 is in {8, 6, 7, 5} and print found or missing.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{8, 6, 7, 5};
    auto it = std::find(v.begin(), v.end(), 8);
    std::cout << (it != v.end() ? "found" : "missing") << "\n";
    return 0;
}
```

algorithm::find.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Use std::find to check if 3 is in {3, 1, 2} and print found or missing.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{3, 1, 2};
    auto it = std::find(v.begin(), v.end(), 3);
    std::cout << (it != v.end() ? "found" : "missing") << "\n";
    return 0;
}
```

algorithm::find.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Use std::find to check if 10 is in {10, 0, -1} and print found or missing.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{10, 0, -1};
    auto it = std::find(v.begin(), v.end(), 10);
    std::cout << (it != v.end() ? "found" : "missing") << "\n";
    return 0;
}
```

algorithm::find.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena el vector {8, 6, 7, 5} con std::sort e imprime los valores separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{8, 6, 7, 5};
    std::sort(v.begin(), v.end());
    for (size_t i = 0; i < v.size(); ++i) {
        if (i) std::cout << " ";
        std::cout << v[i];
    }
    std::cout << "\n";
    return 0;
}
```

algorithm::sort + vector.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Suma los elementos de {10, -3, 2} con std::accumulate e imprime el total.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <numeric>
int main() {
    std::vector<int> v{10, -3, 2};
    int s = std::accumulate(v.begin(), v.end(), 0);
    std::cout << s << "\n";
    return 0;
}
```

numeric::accumulate.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena el vector {3, 1, 2} con std::sort e imprime los valores separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{3, 1, 2};
    std::sort(v.begin(), v.end());
    for (size_t i = 0; i < v.size(); ++i) {
        if (i) std::cout << " ";
        std::cout << v[i];
    }
    std::cout << "\n";
    return 0;
}
```

algorithm::sort + vector.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Reverse {1,2,3,4} with std::reverse and print space-separated.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{1, 2, 3, 4};
    std::reverse(v.begin(), v.end());
    for (size_t i = 0; i < v.size(); ++i) {
        if (i) std::cout << " ";
        std::cout << v[i];
    }
    std::cout << "\n";
    return 0;
}
```

algorithm::reverse.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Use std::find to check if 9 is in {9, 5, 7, 1} and print found or missing.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{9, 5, 7, 1};
    auto it = std::find(v.begin(), v.end(), 9);
    std::cout << (it != v.end() ? "found" : "missing") << "\n";
    return 0;
}
```

algorithm::find.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena el vector {9, 5, 7, 1} con std::sort e imprime los valores separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{9, 5, 7, 1};
    std::sort(v.begin(), v.end());
    for (size_t i = 0; i < v.size(); ++i) {
        if (i) std::cout << " ";
        std::cout << v[i];
    }
    std::cout << "\n";
    return 0;
}
```

algorithm::sort + vector.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena el vector {4, 4, 2} con std::sort e imprime los valores separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{4, 4, 2};
    std::sort(v.begin(), v.end());
    for (size_t i = 0; i < v.size(); ++i) {
        if (i) std::cout << " ";
        std::cout << v[i];
    }
    std::cout << "\n";
    return 0;
}
```

algorithm::sort + vector.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Use std::find to check if 4 is in {4, 4, 2} and print found or missing.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{4, 4, 2};
    auto it = std::find(v.begin(), v.end(), 4);
    std::cout << (it != v.end() ? "found" : "missing") << "\n";
    return 0;
}
```

algorithm::find.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena el vector {10, 0, -1} con std::sort e imprime los valores separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> v{10, 0, -1};
    std::sort(v.begin(), v.end());
    for (size_t i = 0; i < v.size(); ++i) {
        if (i) std::cout << " ";
        std::cout << v[i];
    }
    std::cout << "\n";
    return 0;
}
```

algorithm::sort + vector.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Suma los elementos de {5, 5, 5} con std::accumulate e imprime el total.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <numeric>
int main() {
    std::vector<int> v{5, 5, 5};
    int s = std::accumulate(v.begin(), v.end(), 0);
    std::cout << s << "\n";
    return 0;
}
```

numeric::accumulate.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Define una función add(a,b) e imprime add(2,3).

[Assistant]
```cpp
#include <iostream>
int add(int a, int b) { return a + b; }
int main() {
    std::cout << add(2, 3) << "\n";
    return 0;
}
```

Función libre.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Define a struct Point with x,y; create {3,4} and print x+y.

[Assistant]
```cpp
#include <iostream>
struct Point { int x; int y; };
int main() {
    Point p{3, 4};
    std::cout << p.x + p.y << "\n";
    return 0;
}
```

struct básico.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Usa std::unique_ptr y make_unique para guardar 42 e imprimirlo.

[Assistant]
```cpp
#include <iostream>
#include <memory>
int main() {
    std::unique_ptr<int> p = std::make_unique<int>(42);
    std::cout << *p << "\n";
    return 0;
}
```

memory::unique_ptr / make_unique.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Create unique_ptr to 7, move it, and print the value.

[Assistant]
```cpp
#include <iostream>
#include <memory>
int main() {
    auto p = std::make_unique<int>(7);
    auto q = std::move(p);
    std::cout << *q << "\n";
    return 0;
}
```

move + unique_ptr.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Usa std::optional<int> con valor 9 e imprime value().

[Assistant]
```cpp
#include <iostream>
#include <optional>
int main() {
    std::optional<int> o = 9;
    std::cout << o.value() << "\n";
    return 0;
}
```

optional.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Imprime FizzBuzz clásico solo para i=1..5 (Fizz/Buzz/FizzBuzz/número).

[Assistant]
```cpp
#include <iostream>
int main() {
    for (int i = 1; i <= 5; ++i) {
        if (i % 15 == 0) std::cout << "FizzBuzz\n";
        else if (i % 3 == 0) std::cout << "Fizz\n";
        else if (i % 5 == 0) std::cout << "Buzz\n";
        else std::cout << i << "\n";
    }
    return 0;
}
```

Mini programa con control de flujo.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Compute factorial of 5 in C++ and print it.

[Assistant]
```cpp
#include <iostream>
long long fact(int n) {
    long long r = 1;
    for (int i = 2; i <= n; ++i) r *= i;
    return r;
}
int main() {
    std::cout << fact(5) << "\n";
    return 0;
}
```

Función factorial.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Comprueba si "aba" es palíndromo con reverse e imprime yes/no.

[Assistant]
```cpp
#include <iostream>
#include <string>
#include <algorithm>
int main() {
    std::string s = "aba";
    std::string t = s;
    std::reverse(t.begin(), t.end());
    std::cout << (s == t ? "yes" : "no") << "\n";
    return 0;
}
```

string + reverse.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Count words in "uno dos tres" using istringstream and print the count.

[Assistant]
```cpp
#include <iostream>
#include <sstream>
#include <string>
int main() {
    std::string line = "uno dos tres";
    std::istringstream iss(line);
    std::string w;
    int n = 0;
    while (iss >> w) ++n;
    std::cout << n << "\n";
    return 0;
}
```

sstream.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 0.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 0 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 4.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 4 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 8.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 8 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 12.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 12 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 16.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 16 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 20.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 20 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 24.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 24 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 28.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 28 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 32.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 32 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Programa C++ que imprima 36.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 36 << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 1 enteros 0..0 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 2 enteros 0..1 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 3 enteros 0..2 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1, 2};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 4 enteros 0..3 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1, 2, 3};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 5 enteros 0..4 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1, 2, 3, 4};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 10 enteros 0..9 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 15 enteros 0..14 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 20 enteros 0..19 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea std::vector con 25 enteros 0..24 e imprime size.

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
  std::cout << v.size() << "\n";
  return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {12, 13, 1, 8, 16} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{12, 13, 1, 8, 16};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {19, 4, 9, 3, 2} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{19, 4, 9, 3, 2};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {1, 17, 0, 2, 12} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{1, 17, 0, 2, 12};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {2, 2, 10, 16, 15} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{2, 2, 10, 16, 15};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {19, 12, 10, 18, 7} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{19, 12, 10, 18, 7};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

Solución verificada con g++.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 0.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 0 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 5.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 5 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 10.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 10 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 15.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 15 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 20.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 20 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 25.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 25 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 30.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 30 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 35.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 35 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 40.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 40 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 45.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 45 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 50.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 50 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 55.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 55 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 60.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 60 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 65.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 65 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Escribe un programa C++ que imprima el número 70.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 70 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Write a C++ program that prints the number 75.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << 75 << "\n";
  return 0;
}
```

Impresión de un entero.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Imprime la palabra "ok" en C++.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << "ok\n";
  return 0;
}
```

Impresión de literal.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Imprime la palabra "stl" en C++.

[Assistant]
```cpp
#include <iostream>
int main(){
  std::cout << "stl\n";
  return 0;
}
```

Impresión de literal.


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea un std::vector con {8, 21, 35, 21, 44, 15} e imprime size().

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{8, 21, 35, 21, 44, 15};
  std::cout << v.size() << "\n";
  return 0;
}
```

vector::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea un std::vector con {34, 40, 50, 42, 38, 31, 33, 42, 26, 23, 32, 2} e imprime size().

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{34, 40, 50, 42, 38, 31, 33, 42, 26, 23, 32, 2};
  std::cout << v.size() << "\n";
  return 0;
}
```

vector::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea un std::vector con {34, 24, 4, 34, 44, 40, 25, 1, 20, 16, 30, 2, 48, 35, 21, 26, 22, 1} e imprime size().

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{34, 24, 4, 34, 44, 40, 25, 1, 20, 16, 30, 2, 48, 35, 21, 26, 22, 1};
  std::cout << v.size() << "\n";
  return 0;
}
```

vector::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea un std::vector con {46, 25, 49, 1, 16, 45, 36, 31, 21, 25, 14, 32, 8, 39, 40, 0, 50, 50, 38, 38, 31, 21, 44, 37} e imprime size().

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{46, 25, 49, 1, 16, 45, 36, 31, 21, 25, 14, 32, 8, 39, 40, 0, 50, 50, 38, 38, 31, 21, 44, 37};
  std::cout << v.size() << "\n";
  return 0;
}
```

vector::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea un std::vector con {50, 28, 7, 3, 36, 27, 48, 41, 27, 33, 22, 9, 31, 8, 12, 13, 15, 2, 15, 13, 4, 25, 1, 0, 26, 41, 20, 35, 1, 2} e imprime size().

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{50, 28, 7, 3, 36, 27, 48, 41, 27, 33, 22, 9, 31, 8, 12, 13, 15, 2, 15, 13, 4, 25, 1, 0, 26, 41, 20, 35, 1, 2};
  std::cout << v.size() << "\n";
  return 0;
}
```

vector::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea un std::vector con {47, 34, 12, 25, 40, 43, 4, 12, 13, 46, 22, 27, 49, 30, 18, 41, 35, 34, 10, 24, 1, 16, 46, 1, 48, 40, 43, 10, 49, 12, 23, 11, 6, 8, 45, 38} e imprime size().

[Assistant]
```cpp
#include <iostream>
#include <vector>
int main(){
  std::vector<int> v{47, 34, 12, 25, 40, 43, 4, 12, 13, 46, 22, 27, 49, 30, 18, 41, 35, 34, 10, 24, 1, 16, 46, 1, 48, 40, 43, 10, 49, 12, 23, 11, 6, 8, 45, 38};
  std::cout << v.size() << "\n";
  return 0;
}
```

vector::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Con std::string guarda "map" e imprime length/size.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main(){
  std::string s="map";
  std::cout << s.size() << "\n";
  return 0;
}
```

string::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Con std::string guarda "judge" e imprime length/size.

[Assistant]
```cpp
#include <iostream>
#include <string>
int main(){
  std::string s="judge";
  std::cout << s.size() << "\n";
  return 0;
}
```

string::size


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {13, 22, 8, 9, 13, 27, 5} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{13, 22, 8, 9, 13, 27, 5};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Ordena {18, 20, 25, 10, 6, 5, 1} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{18, 20, 25, 10, 6, 5, 1};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {10, 10, 30, 19, 20, 27} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{10, 10, 30, 19, 20, 27};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Ordena {16, 21, 0, 15, 4, 8} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{16, 21, 0, 15, 4, 8};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {21, 29, 17, 15, 23, 24, 26, 18} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{21, 29, 17, 15, 23, 24, 26, 18};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Ordena {19, 15, 16} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{19, 15, 16};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {20, 29, 14, 29, 23, 13, 30, 14} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{20, 29, 14, 29, 23, 13, 30, 14};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] You are an assistant that only programs in modern C++ (C++20). Reply with a short explanation and one complete compilable ```cpp``` code block.

[User] Ordena {11, 7, 17, 24, 27, 1} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{11, 7, 17, 24, 27, 1};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Ordena {12, 18, 18, 19, 16} con std::sort e imprime separados por espacio.

[Assistant]
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v{12, 18, 18, 19, 16};
  std::sort(v.begin(), v.end());
  for(size_t i=0;i<v.size();++i){ if(i) std::cout<<' '; std::cout<<v[i]; }
  std::cout<<"\n"; return 0;
}
```

std::sort


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Define add(a,b) e imprime add(2,3).

[Assistant]
```cpp
#include <iostream>
int add(int a,int b){return a+b;}
int main(){ std::cout << add(2,3) << "\n"; return 0; }
```

función libre


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Struct Point con x,y; crea {5,2} e imprime x+y.

[Assistant]
```cpp
#include <iostream>
struct Point{int x;int y;};
int main(){ Point p{5,2}; std::cout << (p.x+p.y) << "\n"; return 0; }
```

struct Point


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Crea shared_ptr, cópialo e imprime use_count().

[Assistant]
```cpp
#include <iostream>
#include <memory>
int main(){
  auto p=std::make_shared<int>(1);
  auto q=p;
  std::cout << p.use_count() << "\n";
  return 0;
}
```

shared_ptr


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Calcula factorial de 5 e imprímelo.

[Assistant]
```cpp
#include <iostream>
long long fact(int n){long long r=1; for(int i=2;i<=n;++i)r*=i; return r;}
int main(){ std::cout << fact(5) << "\n"; return 0; }
```

factorial


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Calcula factorial de 4 e imprímelo.

[Assistant]
```cpp
#include <iostream>
long long fact(int n){long long r=1; for(int i=2;i<=n;++i)r*=i; return r;}
int main(){ std::cout << fact(4) << "\n"; return 0; }
```

factorial


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] Calcula factorial de 6 e imprímelo.

[Assistant]
```cpp
#include <iostream>
long long fact(int n){long long r=1; for(int i=2;i<=n;++i)r*=i; return r;}
int main(){ std::cout << fact(6) << "\n"; return 0; }
```

factorial


[System] Eres un asistente que solo programa en C++ moderno (C++20). Responde con una breve explicación y un único bloque de código ```cpp``` completo y compilable.

[User] FizzBuzz para i=1..5.

[Assistant]
```cpp
#include <iostream>
int main(){
  for(int i=1;i<=5;++i){
    if(i%15==0) std::cout<<"FizzBuzz\n";
    else if(i%3==0) std::cout<<"Fizz\n";
    else if(i%5==0) std::cout<<"Buzz\n";
    else std::cout<<i<<"\n";
  }
  return 0;
}
```

FizzBuzz