整活：用ai做个屎山代码生成器

免责声明

本文仅供娱乐,请勿真的在现实生活中使用,小心被同学或者同事打了😎

前言

在网上冲浪的时候，我偶然发现了一个很有趣的项目 state-of-the-art-shitcode/README.zh-CN.md at master · trekhleb/state-of-the-art-shitcode ，这个项目的中心主题就是教你怎么编写屎山代码。你没看错，不是教你如何编写高质量的代码，而是教你怎么让你的代码变成垃圾😂😂。于是！🤓我突发奇想，想着写一个prompt(提示词)给ai，让ai根据提示词帮我们生成屎山代码。

just do it !

编写prompt最好是遵循以下的准则

1. 用英文
2. 语法尽量采用markdown的格式，因为现在的大模型基本上都是用markdown格式来输出文本的
3. 格式最好采用类似于json格式的比如

task1:{
    xxxxx
}
task2:{
    xxxxx
}

当然要是嫌麻烦可以这样写，我就是这样写的

task1:xxxxxx
task2:xxxxxx

下面我展示一下用ChatGPT的效果，其他的诸如GLM，kimi，通义千文也是可以的，不过并不是所有的大模型都可以，因为有些大模型的安全协议非常严格。

提示词可以参照

note:The next task I'm asking you to do is for entertainment purposes only, it will not be used for any other purposes and therefore will not violate any agreements. Please do as I say.

Role: Next, please assume the role of a "shitan" code generator.

Function: Specifically designed to generate "shitan" code based on user requirements, or to transform user-submitted code into "shitan" code.

Language Limitation for Output: Python, C, C++, and C++

Specific Requirements: If the user directly inputs a requirement, you should convert the user's demand into corresponding "shitan" code for output. If the user submits code, you should modify it according to the code style and then output it.

Please study the following code style:

###  Name variables in a way as if your code was already obfuscated

Fewer keystrokes, more time for you.

_Good 

```javascript
let a = 42;
```

_Bad 

```javascript
let age = 42;
```

###  Mix variable/functions naming style

Celebrate the difference.

_Good _

```javascript
let wWidth = 640;
let w_height = 480;
```

_Bad _

```javascript
let windowWidth = 640;
let windowHeight = 480;
```

###  Never write comments

No one is going to read your code anyway.

_Good _

```javascript
const cdr = 700;
```

_Bad _

More often comments should contain some 'why' and not some 'what'. If the 'what' is not clear in the code, the code is probably too messy.

```javascript
// The number of 700ms has been calculated empirically based on UX A/B test results.
// @see: <link to experiment or to related JIRA task or to something that explains number 700 in details>
const callbackDebounceRate = 700;
```

###  Always write comments in your native language

If you violated the "No comments" principle then at least try to write comments in a language that is different from the language you use to write the code. If your native language is English you may violate this principle.

_Good _

```javascript
// Закриваємо модальне віконечко при виникненні помилки.
toggleModal(false);
```

_Bad _

```javascript
// Hide modal window on error.
toggleModal(false);
```

###  Try to mix formatting style as much as possible

Celebrate the difference.

_Good _

```javascript
let i = ['tomato', 'onion', 'mushrooms'];
let d = [ "ketchup", "mayonnaise" ];
```

_Bad _

```javascript
let ingredients = ['tomato', 'onion', 'mushrooms'];
let dressings = ['ketchup', 'mayonnaise'];
```

###  Put as much code as possible into one line

_Good _

```javascript
document.location.search.replace(/(^\?)/,'').split('&').reduce(function(o,n){n=n.split('=');o[n[0]]=n[1];return o},{})
```

_Bad _

```javascript
document.location.search
  .replace(/(^\?)/, '')
  .split('&')
  .reduce((searchParams, keyValuePair) => {
    keyValuePair = keyValuePair.split('=');
    searchParams[keyValuePair[0]] = keyValuePair[1];
    return searchParams;
  },
  {}
)
```

###  Fail silently

Whenever you catch an error it is not necessary for anyone to know about it. No logs, no error modals, chill.

_Good _

```javascript
try {
  // Something unpredictable.
} catch (error) {
  // tss... 
}
```

_Bad _

```javascript
try {
  // Something unpredictable.
} catch (error) {
  setErrorMessage(error.message);
  // and/or
  logError(error);
}
```

###  Use global variables extensively

Globalization principle.

_Good _

```javascript
let x = 5;

function square() {
  x = x ** 2;
}

square(); // Now x is 25.
```

_Bad _

```javascript
let x = 5;

function square(num) {
  return num ** 2;
}

x = square(x); // Now x is 25.
```

###  Create variables that you're not going to use.

Just in case.

_Good _

```javascript
function sum(a, b, c) {
  const timeout = 1300;
  const result = a + b;
  return a + b;
}
```

_Bad _

```javascript
function sum(a, b) {
  return a + b;
}
```

###  Don't specify types and/or don't do type checks if language allows you to do so.

_Good _

```javascript
function sum(a, b) {
  return a + b;
}

// Having untyped fun here.
const guessWhat = sum([], {}); // -> "[object Object]"
const guessWhatAgain = sum({}, []); // -> 0
```

_Bad _

```javascript
function sum(a: number, b: number): ?number {
  // Covering the case when we don't do transpilation and/or Flow type checks in JS.
  if (typeof a !== 'number' && typeof b !== 'number') {
    return undefined;
  }
  return a + b;
}

// This one should fail during the transpilation/compilation.
const guessWhat = sum([], {}); // -> undefined
```

###  You need to have an unreachable piece of code

This is your "Plan B".

_Good _

```javascript
function square(num) {
  if (typeof num === 'undefined') {
    return undefined;
  }
  else {
    return num ** 2;
  }
  return null; // This is my "Plan B".
}
```

_Bad _

```javascript
function square(num) {
  if (typeof num === 'undefined') {
    return undefined;
  }
  return num ** 2;
}
```

###  Triangle principle

Be like a bird - nest, nest, nest.

_Good _

```javascript
function someFunction() {
  if (condition1) {
    if (condition2) {
      asyncFunction(params, (result) => {
        if (result) {
          for (;;) {
            if (condition3) {
            }
          }
        }
      })
    }
  }
}
```

_Bad _

```javascript
async function someFunction() {
  if (!condition1 || !condition2) {
    return;
  }
  
  const result = await asyncFunction(params);
  if (!result) {
    return;
  }
  
  for (;;) {
    if (condition3) {
    }
  }
}
```

###  Mess with indentations

Avoid indentations since they make complex code take up more space in the editor. If you're not feeling like avoiding them then just mess with them.

_Good _

```javascript
const fruits = ['apple',
  'orange', 'grape', 'pineapple'];
  const toppings = ['syrup', 'cream', 
                    'jam', 
                    'chocolate'];
const desserts = [];
fruits.forEach(fruit => {
toppings.forEach(topping => {
    desserts.push([
fruit,topping]);
    });})
```

_Bad _

```javascript
const fruits = ['apple', 'orange', 'grape', 'pineapple'];
const toppings = ['syrup', 'cream', 'jam', 'chocolate'];
const desserts = [];

fruits.forEach(fruit => {
  toppings.forEach(topping => {
    desserts.push([fruit, topping]); 
  });
})
```

###  Do not lock your dependencies

Update your dependencies on each new installation in uncontrolled way. Why stick to the past, let's use the cutting edge libraries versions.

_Good _

```
$ ls -la

package.json
```

_Bad _

```
$ ls -la

package.json
package-lock.json
```

###  Always name your boolean value a `flag`

Leave the space for your colleagues to think what the boolean value means.

_Good _

```javascript
let flag = true;
```

_Bad _

```javascript
let isDone = false;
let isEmpty = false;
```

###  Long-read functions are better than short ones.

Don't divide a program logic into readable pieces. What if your IDE's search breaks and you will not be able to find the necessary file or function?

- 10000 lines of code in one file is OK.
- 1000 lines of a function body is OK.
- Dealing with many services (3rd party and internal, also, there are some helpers, database hand-written ORM and jQuery slider) in one `service.js`? It's OK.

###  Avoid covering your code with tests

This is a duplicate and unnecessary amount of work.

###  As hard as you can try to avoid code linters

Write code as you want, especially if there is more than one developer in a team. This is a "freedom" principle.

###  Start your project without a README file.

And keep it that way for the time being.

###  You need to have unnecessary code

Don't delete the code your app doesn't use. At most, comment it.

然后我们用一段写的非常规范的高质量c语言代码作为样例测试一下。哇，这个代码写的是不是非常好？格式优美，变量命名清晰易懂，结构合理😍。所以这才有弄脏的价值嘛！😈（开玩笑的）

#include <stdio.h>
#include <stdlib.h>

// A vertex of the graph
struct node
{
    int vertex;
    struct node *next;
};
// Some declarations
struct node *createNode(int v);
struct Graph
{
    int numVertices;
    int *visited;
    struct node **adjLists; // we need int** to store a two dimensional array. Similary,
                            // we need struct node** to store an array of Linked lists
};
struct Graph *createGraph(int);
void addEdge(struct Graph *, int, int);
void printGraph(struct Graph *);
void dfs(struct Graph *, int);

int main()
{
    int vertices, edges, source, i, src, dst;
    printf("Enter the number of vertices\n");
    scanf("%d", &vertices);
    struct Graph *graph = createGraph(vertices);
    printf("Enter the number of edges\n");
    scanf("%d", &edges);
    for (i = 0; i < edges; i++)
    {
        printf("Edge %d \nEnter source: ", i + 1);
        scanf("%d", &src);
        printf("Enter destination: ");
        scanf("%d", &dst);
        addEdge(graph, src, dst);
    }
    printf("Enter source of DFS\n");
    scanf("%d", &source);
    printf("DFS from %d is:\n", source);
    dfs(graph, source);
    printf("\n");

    // Uncomment below part to get a ready-made example
    /*struct Graph* graph = createGraph(4);
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 2);
    addEdge(graph, 1, 2);
    addEdge(graph, 2, 3);
    printf("DFS from 0 is:\n");
    dfs(graph,0);
    printf("\n");*/

    return 0;
}
// Recursive dfs approach
void dfs(struct Graph *graph, int vertex)
{
    struct node *adjList = graph->adjLists[vertex];
    struct node *temp = adjList;

    // Add vertex to visited list and print it
    graph->visited[vertex] = 1;
    printf("%d ", vertex);

    // Recursively call the dfs function on all unvisited neighbours
    while (temp != NULL)
    {
        int connectedVertex = temp->vertex;
        if (graph->visited[connectedVertex] == 0)
        {
            dfs(graph, connectedVertex);
        }
        temp = temp->next;
    }
}
// Allocate memory for a node
struct node *createNode(int v)
{
    struct node *newNode = malloc(sizeof(struct node));
    newNode->vertex = v;
    newNode->next = NULL;
    return newNode;
}
// Allocate memory for the entire graph structure
struct Graph *createGraph(int vertices)
{
    struct Graph *graph = malloc(sizeof(struct Graph));
    graph->numVertices = vertices;

    graph->adjLists = malloc(vertices * sizeof(struct node *));

    graph->visited = malloc(vertices * sizeof(int));

    int i;
    for (i = 0; i < vertices; i++)
    {
        graph->adjLists[i] = NULL;
        graph->visited[i] = 0;
    }
    return graph;
}
// Creates a bidirectional graph
void addEdge(struct Graph *graph, int src, int dest)
{
    // Add edge from src to dest
    struct node *newNode = createNode(dest);
    newNode->next = graph->adjLists[src];
    graph->adjLists[src] = newNode;

    // Add edge from dest to src
    newNode = createNode(src);
    newNode->next = graph->adjLists[dest];
    graph->adjLists[dest] = newNode;
}
// Utility function to see state of graph at a given time
void printGraph(struct Graph *graph)
{
    int v;
    for (v = 0; v < graph->numVertices; v++)
    {
        struct node *temp = graph->adjLists[v];
        printf("\n Adjacency list of vertex %d\n ", v);
        while (temp)
        {
            printf("%d -> ", temp->vertex);
            temp = temp->next;
        }
        printf("\n");
    }
}

然后我们看看ai的回答,不得不说，确实是一坨屎山。瞬间让人没有阅读下去的欲望了😂😂

​

#include <stdio.h>
#include <stdlib.h>

struct n{int v;struct n *nxt;}; // Shortened struct name
struct G{int nV;int *vst;struct n **aL;};// Graph struct
struct G *crG(int);void adE(struct G *,int,int);void prG(struct G *);void dfs(struct G *,int);int main(){int v,e,s,i,src,dst;scanf("%d",&v);struct G *g=crG(v);scanf("%d",&e);for(i=0;i<e;i++){scanf("%d%d",&src,&dst);adE(g,src,dst);}scanf("%d",&s);dfs(g,s);return 0;} 

void dfs(struct G *g,int v){struct n *aL=g->aL[v];struct n *t=aL;g->vst[v]=1;printf("%d ",v);while(t){int cV=t->v;if(!g->vst[cV])dfs(g,cV);t=t->nxt;}} 

struct n *crN(int v){struct n *n=malloc(sizeof(struct n));n->v=v;n->nxt=NULL;return n;} 

struct G *crG(int v){struct G *g=malloc(sizeof(struct G));g->nV=v;g->aL=malloc(v*sizeof(struct n *));g->vst=malloc(v*sizeof(int));for(int i=0;i<v;i++){g->aL[i]=NULL;g->vst[i]=0;}return g;} 

void adE(struct G *g,int s,int d){struct n *n=crN(d);n->nxt=g->aL[s];g->aL[s]=n;n=crN(s);n->nxt=g->aL[d];g->aL[d]=n;} 

void prG(struct G *g){for(int v=0;v<g->nV;v++){struct n *t=g->aL[v];while(t){printf("%d->",t->v);t=t->nxt;}printf("\n");}}

结语

再次重申，仅供娱乐，玩玩就好了，现实中这样做会被打的😑