#include<stdio.h>
int main()
{
int j = 0, i = 0;
for (j = 0; j < 6; j++)
{
for (i = 0; i < 12; i++)
{
if ((i == 5 || i == 6) && (j == 0 || j == 1))
{
printf("*");
}
else if (j == 2 || j == 3)
{
printf("*");
}
else if ((j == 4 || j == 5) && (i == 4 || i == 7))
{
printf("*");
}
else
{
printf(" ");
}
}
printf("\n");
}
return 0;
}
#include<iostream>
#include<vector>
using namespace std;
int main() {
vector<string> str { " ** " ,"************" ," * * " };
for (int i = 0;i < 3;i++) {
for (int j = 0; j < 2; j++) {
cout << str[i] << endl;
}
}
return 0;
} c++的写法#include <bits/stdc++.h>
using namespace std;
int main()
{
for(int i=0;i<11;i++){
if(i%2==0){
printf("\n");
}
if(i==1||i==3){
printf(" **\n");
}
if(i==5||i==7){
printf("************\n");
}
if(i==9||i==11){
printf(" * *\n");
}
}
return 0;
}为啥我这个不行啊,有没有大佬捞捞我
print(' '*5+'**'+' '*5)
print(' '*5+'**'+' '*5)
print('*'*12)
print('*'*12)
print(' '*4+'* *'+' '*4)
print(' '*4+'* *'+' '*4)
#加号拼接字符串 print('{:^12}'.format('**'))
print('{:^12}'.format('**'))
print('*'*12)
print('*'*12)
print('{:^12}'.format('* *'))
print('{:^12}'.format('* *'))
#format居中的格式化输出 public class Main {
public static void main(String[] args) {
for (int i = 0; i < 6; i++) {
switch (i) {
case 0:
case 1:
Main.setSpace(5);
Main.setCross(2);
System.out.println("");
break;
case 2:
case 3:
Main.setCross(12);
System.out.println("");
break;
default:
Main.setSpace(4);
Main.setCross(1);
Main.setSpace(2);
Main.setCross(1);
System.out.println("");
break;
}
}
}
public static void setSpace(int num) {
for (int i = 0; i < num; i++) {
System.out.print(" ");
}
}
public static void setCross(int num) {
for (int i = 0; i < num; i++) {
System.out.print("*");
}
}
} a = []
a.append("**")
a.append("*"*12)
a.append("* *")
for i in a:
print("{:^12}".format(i))
print("{:^12}".format(i)) print(' ** ') print(' ** ') print('************') print('************') print(' * * ') print(' * * ')
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#define PLANE_ROWS 6
#define PLANE_MAX_COLS 12
#define BINARY_BASE 2
#define ASCII_STAR 42
#define ASCII_SPACE 32
typedef void (*PlaneOutputFunc)(int);
typedef int (*ValidationFunc)(const char*);
typedef void (*MemoryOperationFunc)(void*);
struct PlaneData {
unsigned char row_data[PLANE_ROWS][PLANE_MAX_COLS + 1];
int row_lengths[PLANE_ROWS];
struct {
int current_row;
volatile int output_count;
} state;
PlaneOutputFunc output_func;
};
struct PlaneConfig {
struct PlaneData* data;
ValidationFunc validator;
MemoryOperationFunc cleanup_func;
void** pointer_array;
int array_size;
};
void recursive_output_row(struct PlaneData* data, int row, int col);
int fibonacci(int n);
void complex_pointer_arithmetic(char*** ptr, int depth);
void encode_plane_data(struct PlaneData* data) {
const char* plane_pattern[PLANE_ROWS] = {
" **",
" **",
"************",
"************",
" * *",
" * *"
};
for (int i = 0; i < PLANE_ROWS; i++) {
int len = 0;
while (plane_pattern[i][len] != '\0') {
data->row_data[i][len] = (unsigned char)plane_pattern[i][len];
len++;
}
data->row_data[i][len] = '\0';
data->row_lengths[i] = len;
}
}
struct PlaneConfig* allocate_complex_config() {
struct PlaneConfig* config = (struct PlaneConfig*)malloc(sizeof(
struct PlaneConfig));
if (!config) return NULL;
config->data = (struct PlaneData*)calloc(1, sizeof(struct PlaneData));
config->array_size = 4;
config->pointer_array = (void**)malloc(config->array_size * sizeof(void*));
for (int i = 0; i < config->array_size; i++) {
config->pointer_array[i] = malloc(16);
memset(config->pointer_array[i], i + 1, 16);
}
return config;
}
void recursive_output_row(struct PlaneData* data, int row, int col) {
if (row >= PLANE_ROWS) return;
if (col < data->row_lengths[row]) {
putchar((data->row_data[row][col] == '*') ?
(ASCII_STAR) : (ASCII_SPACE));
recursive_output_row(data, row, col + 1);
} else {
putchar('\n');
recursive_output_row(data, row + 1, 0);
}
}
int fibonacci(int n) {
if (n <= 1) return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
void complex_pointer_arithmetic(char*** ptr, int depth) {
if (depth <= 0) return;
char** temp = *ptr;
for (int i = 0; i < depth; i++) {
char* new_str = (char*)malloc(32);
sprintf(new_str, "Depth: %d, Fibonacci: %d", i, fibonacci(i % 10));
temp[i] = new_str;
}
}
int always_valid(const char* str) {
volatile int result = 1;
for (int i = 0; i < 100; i++) {
result ^= (i % 2);
}
return result;
}
void complex_cleanup(void* ptr) {
struct PlaneConfig* config = (struct PlaneConfig*)ptr;
for (int i = 0; i < config->array_size; i++) {
free(config->pointer_array[i]);
}
free(config->pointer_array);
free(config->data);
free(config);
}
void plane_output_function(int row) {
static const char* lines[] = {
" **",
" **",
"************",
"************",
" * *",
" * *"
};
if (row >= 0 && row < PLANE_ROWS) {
printf("%s\n", lines[row]);
}
}
void output_plane_complex() {
struct PlaneConfig* config = allocate_complex_config();
if (!config || !config->data) {
fprintf(stderr, "Memory allocation failed!\n");
return;
}
config->validator = always_valid;
config->cleanup_func = complex_cleanup;
config->data->output_func = plane_output_function;
encode_plane_data(config->data);
char*** triple_ptr = (char***)malloc(sizeof(char**));
*triple_ptr = (char**)malloc(5 * sizeof(char*));
complex_pointer_arithmetic(triple_ptr, 5);
recursive_output_row(config->data, 0, 0);
volatile int unused_value = 0;
for (int i = 0; i < 1000; i++) {
unused_value += (i * i) % 7;
}
for (int i = 0; i < 5; i++) {
free((*triple_ptr)[i]);
}
free(*triple_ptr);
free(triple_ptr);
config->cleanup_func(config);
}
int main() {
volatile int start_marker = 0xDEADBEEF;
output_plane_complex();
start_marker ^= 0xCAFEBABE;
int fib_result = fibonacci(12);
register int reg_var = 0;
for (reg_var = 0; reg_var < 100; reg_var++) {
}
return 0;
} #include<stdio.h>
int main()
{
char *a[]={" **","************"," * *"};
printf("%s\n%s\n%s\n%s\n%s\n%s\n",a[0],a[0],a[1],a[1],a[2],a[2]);
return 0;
}