令人膛目结舌的代码技巧！！！

你见过哪些令你膛目结舌的代码技巧？

代码世界有很多令人大呼小叫的技巧！有的代码像魔术师一样巧妙地隐藏了自己，有的像魔法师一样让你眼花缭乱，还有的像瑜伽大师一样灵活自如。它们让我们惊叹不已，让我们觉得自己仿佛置身于编码的魔幻世界。快来分享你见过哪些令你膛目结舌的代码技巧吧！

> 提醒：在发布作品前，请把不需要的内容删掉。
方向一：编程语言介绍

提示：可介绍你所掌握的高级编程语言，如Python, Java, C++等，并说明该语言的独特优势和应用场景

方向二：代码技巧分享

提示：可以分享令你膛目结舌的代码技巧

方向三：案例分享

提示：可以分享自己写过厉害的代码技巧，并且解决过的案例

Python：
1、一行代码迭代列表：

# 使用列表推导式将列表中的每个元素加倍
doubled_list = [x * 2 for x in original_list]

这个技巧使用了列表推导式，它允许在一行代码中创建新的列表。在这个例子中，original_list 中的每个元素都被乘以2，形成一个新的列表 doubled_list。

2、条件运算符的巧妙使用：

# 使用条件运算符交换两个变量的值
a, b = b, a if a > b else b, a

这个例子展示了条件运算符的简洁性。通过使用 (a, b) = (b, a) if a > b else (a, b)，你可以交换两个变量的值，而无需使用额外的临时变量。

3、Lambda 函数的简洁性：

# 使用 lambda 函数计算两个数的和
add = lambda x, y: x + y

Lambda 函数是一种匿名函数，它可以在一行中定义。在这个例子中，lambda 函数被用来定义一个简单的加法函数。

4、装饰器的优雅应用：

创建一个简单的日志装饰器

def log_function(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function {func.__name__} with arguments {args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} returned {result}")
        return result
    return wrapper

@log_function
def add(a, b):
    return a + b

装饰器是一种用于修改函数行为的强大工具。在这个例子中，log_function 装饰器添加了打印日志的功能，它可以装饰其他函数，以便在函数调用时输出日志信息。

5、生成器的巧妙运用：

# 使用生成器表达式生成斐波那契数列
fibonacci = (x if x <= 1 else fibonacci[x-1] + fibonacci[x-2] for x in range(10))

生成器表达式是一种创建生成器的简明语法。在这个例子中，通过使用生成器表达式，我们可以生成一个包含斐波那契数列的生成器。

6、Python 的链式比较：

# 使用链式比较检查一个数字是否在某个范围内
num = 5
if 1 < num < 10:
    print("Number is between 1 and 10")

Python 允许使用链式比较，这使得在一个条件语句中检查一个数字是否在某个范围内变得非常简单和可读。

7、Magic Methods 的魔法：

# 使用 __str__ 和 __add__ 魔法方法使类的实例能够被打印和相加
class MagicNumber:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return str(self.value)

    def __add__(self, other):
        return MagicNumber(self.value + other.value)

num1 = MagicNumber(5)
num2 = MagicNumber(10)
result = num1 + num2
print(result)  # 输出 "15"

在这个例子中，定义了一个 MagicNumber 类，它使用了两个特殊方法（魔法方法）str 和 add。str 方法定义了实例被打印时的行为，而 add 方法定义了实例相加时的行为。这使得 MagicNumber 实例可以像普通数字一样被打印和相加。

---

---

C语言：
1、斐波那契数列的迭代实现：

#include <stdio.h>

int fibonacci(int n) {
    int a = 0, b = 1;
    for (int i = 2; i <= n; ++i) {
        int temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

int main() {
    int n = 5;
    printf("Fibonacci(%d): %d\n", n, fibonacci(n));

    return 0;
}

2、使用位操作检查奇偶性：

#include <stdio.h>

int isEven(int num) {
    return (num & 1) == 0;
}

int main() {
    int number = 10;
    if (isEven(number)) {
        printf("%d is even.\n", number);
    } else {
        printf("%d is odd.\n", number);
    }

    return 0;
}

3、巧妙的条件交换：

#include <stdio.h>

int main() {
    int a = 5, b = 10;

    // 使用异或运算符实现条件交换
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;

    printf("a: %d, b: %d\n", a, b);

    return 0;
}

4、快速幂算法：

#include <stdio.h>

int power(int base, int exponent) {
    int result = 1;
    while (exponent > 0) {
        if (exponent & 1) {
            result *= base;
        }
        base *= base;
        exponent >>= 1;
    }
    return result;
}

int main() {
    int base = 2, exponent = 5;
    printf("%d^%d: %d\n", base, exponent, power(base, exponent));

    return 0;
}

5、使用位操作实现交替打印：

#include <stdio.h>

void alternatePrint(int n) {
    for (int i = 1; i <= n; ++i) {
        printf("%s ", i & 1 ? "Odd" : "Even");
    }
}

int main() {
    int n = 10;
    alternatePrint(n);
    return 0;
}

这个例子展示了如何使用位操作检测奇偶性，从而实现交替打印奇数和偶数。

6、异或链表节点交换：

#include <stdio.h>

struct Node {
    int data;
    struct Node* next;
};

void xorSwap(struct Node* a, struct Node* b) {
    if (a != b) {
        a->data ^= b->data;
        b->data ^= a->data;
        a->data ^= b->data;
    }
}

int main() {
    // 假设有两个节点 a 和 b
    struct Node* a = /* 初始化 */;
    struct Node* b = /* 初始化 */;

    xorSwap(a, b);

    return 0;
}

这个例子演示了如何使用异或操作在不使用额外空间的情况下交换两个链表节点的数据。

7、斐波那契数列的尾递归优化：

#include <stdio.h>

int fibonacciTailRecursive(int n, int a, int b) {
    return (n == 0) ? a : fibonacciTailRecursive(n - 1, b, a + b);
}

int main() {
    int n = 9;
    printf("Fibonacci(%d): %d\n", n, fibonacciTailRecursive(n, 0, 1));
    return 0;
}

这个例子使用尾递归优化来计算斐波那契数列，提高了性能并避免了递归深度过大的问题。

8、二分查找的递归实现：

#include <stdio.h>

int binarySearch(int arr[], int low, int high, int target) {
    if (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            return binarySearch(arr, mid + 1, high, target);
        } else {
            return binarySearch(arr, low, mid - 1, target);
        }
    }
    return -1;  // 未找到目标值
}

int main() {
    int sortedArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int target = 7;
    int index = binarySearch(sortedArray, 0, sizeof(sortedArray) / sizeof(sortedArray[0]) - 1, target);

    if (index != -1) {
        printf("Target %d found at index %d\n", target, index);
    } else {
        printf("Target %d not found in the array\n", target);
    }

    return 0;
}

9、快速排序算法：

#include <stdio.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; ++j) {
        if (arr[j] < pivot) {
            ++i;
            swap(&arr[i], &arr[j]);
        }
    }

    swap(&arr[i + 1], &arr[high]);
    return i + 1;
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high);
        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
}

int main() {
    int array[] = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6};
    int n = sizeof(array) / sizeof(array[0]);

    quickSort(array, 0, n - 1);

    printf("Sorted array: ");
    for (int i = 0; i < n; ++i) {
        printf("%d ", array[i]);
    }
    printf("\n");

    return 0;
}

---

---

其他：
1、代码的魔术：

 def magic_trick(*args):
    return sum(args) / len(args) if args else None

这个函数展示了一种巧妙的技巧，通过使用三元条件运算符处理了空输入的情况，避免了除零错误。

2、代码的魔法：

const magicArray = Array.from({ length: 5 }, (_, index) => index + 1);

这段 JavaScript 代码使用了 Array.from 和箭头函数，以一种非常简洁的方式创建了包含数字 1 到 5 的数组。

3、代码的瑜伽：

public class YogaMaster {
    private static final YogaMaster instance = new YogaMaster();

    private YogaMaster() {
        // Private constructor to prevent instantiation
    }

    public static YogaMaster getInstance() {
        return instance;
    }
}

这个 Java 类使用了单例模式，确保只有一个实例存在。私有构造函数和静态方法 getInstance 使得类的实例灵活自如地被管理。

4、代码的魔法师：

var magicNumber = 42;
Console.WriteLine($"The magic number is: {magicNumber}");

在C#中，使用字符串插值和 $ 符号，可以在字符串中直接引用变量，让输出语句更加简洁和可读。

5、代码的巧妙隐藏：

class HiddenCode
  def method_missing(method, *args, &block)
    puts "Shh... It's a secret!"
  end
end

这段 Ruby 代码使用 method_missing 方法，当调用未定义的方法时，会输出一个秘密的信息，巧妙地隐藏了未知方法的存在。