Map를 언어별로 비교하기

// 불변 컬렉션
val list = listOf(1, 2, 3, 4, 5)
val set  = setOf("a", "b", "c", "b")    // 중복 제거
val map  = mapOf("one" to 1, "two" to 2)

// 가변 컬렉션
val mList = mutableListOf(1, 2, 3)
mList.add(4)
mList.removeAt(0)
mList[0] = 99

val mMap = mutableMapOf("a" to 1)
mMap["b"] = 2
mMap.remove("a")

// 읽기 안전
println(map["one"])          // 1 (Int?)
println(map.getOrDefault("three", 0))  // 0
println(map.getOrElse("three") { -1 }) // -1

// 컬렉션 + 연산
val combined = list + listOf(6, 7)     // 새 리스트 반환
val filtered = list - listOf(2, 4)     // [1, 3, 5]

// 배열
val arr = arrayOf(1, 2, 3)
val intArr = intArrayOf(1, 2, 3)       // primitive 배열
println(intArr.sum())                   // 6

import asyncio

# asyncio.Queue — Producer/Consumer 패턴
async def producer(queue: asyncio.Queue, count: int):
    for i in range(count):
        await asyncio.sleep(0.1)
        await queue.put(f"item-{i}")
        print(f"생산: item-{i}")
    await queue.put(None)  # 종료 신호

async def consumer(queue: asyncio.Queue, name: str):
    while True:
        item = await queue.get()
        if item is None:
            await queue.put(None)  # 다음 컨슈머에게 전달
            break
        await asyncio.sleep(0.2)
        print(f"{name} 소비: {item}")
        queue.task_done()

# Semaphore — 동시 실행 수 제한
async def fetch_with_limit(
    sem: asyncio.Semaphore,
    url: str
) -> str:
    async with sem:   # 동시에 최대 3개만 실행
        await asyncio.sleep(0.1)
        return f"data:{url}"

async def main():
    # Queue 예제
    queue = asyncio.Queue(maxsize=5)
    await asyncio.gather(
        producer(queue, 5),
        consumer(queue, "Worker-1"),
        consumer(queue, "Worker-2"),
    )

    # Semaphore 예제
    sem = asyncio.Semaphore(3)  # 동시 3개 제한
    urls = [f"url-{i}" for i in range(10)]
    results = await asyncio.gather(
        *[fetch_with_limit(sem, url) for url in urls]
    )
    print(f"완료: {len(results)}개")

asyncio.run(main())

package main

import (
	"fmt"
	"sort"
)

func main() {
	// 맵 생성
	m1 := map[string]int{
		"apple":  5,
		"banana": 3,
		"cherry": 8,
	}
	m2 := make(map[string]int)       // 빈 맵
	m2["key"] = 100

	// 읽기 & 존재 확인 (comma-ok 패턴)
	val, ok := m1["apple"]
	if ok {
		fmt.Println("apple:", val)
	}

	val2 := m1["durian"] // 없으면 zero value (0)
	fmt.Println("durian:", val2)

	// 삭제
	delete(m1, "banana")

	// 순회 (순서 보장 안 됨)
	keys := make([]string, 0, len(m1))
	for k := range m1 { keys = append(keys, k) }
	sort.Strings(keys) // 정렬
	for _, k := range keys {
		fmt.Printf("%s: %d
", k, m1[k])
	}

	// 중첩 맵
	graph := map[string][]string{
		"A": {"B", "C"},
		"B": {"D"},
		"C": {"D", "E"},
	}
	fmt.Println(graph["A"])

	// 빈도 카운팅 패턴
	words := []string{"go", "is", "great", "go", "is"}
	freq := make(map[string]int)
	for _, w := range words { freq[w]++ }
	fmt.Println(freq)

	// 구조체를 값으로
	type Point struct{ X, Y int }
	points := map[string]Point{
		"origin": {0, 0},
		"unit":   {1, 1},
	}
	fmt.Println(points["unit"])
}

public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS  (4.869e+24, 6.0518e6),
    EARTH  (5.976e+24, 6.37814e6),
    MARS   (6.421e+23, 3.3972e6);

    private final double mass;    // 질량 (kg)
    private final double radius;  // 반지름 (m)

    Planet(double mass, double radius) {
        this.mass   = mass;
        this.radius = radius;
    }

    static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }

    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

// 추상 메서드를 가진 Enum
enum Operation {
    PLUS("+")  { @Override double apply(double x, double y) { return x + y; } },
    MINUS("-") { @Override double apply(double x, double y) { return x - y; } },
    TIMES("*") { @Override double apply(double x, double y) { return x * y; } },
    DIVIDE("/") { @Override double apply(double x, double y) { return x / y; } };

    private final String symbol;
    Operation(String symbol) { this.symbol = symbol; }
    abstract double apply(double x, double y);

    @Override public String toString() { return symbol; }
}

class Main {
    public static void main(String[] args) {
        double earthWeight = 75.0;
        double mass = earthWeight / Planet.EARTH.surfaceGravity();
        for (Planet p : Planet.values()) {
            System.out.printf("체중 on %s: %.2f%n",
                p, p.surfaceWeight(mass));
        }

        double x = 10, y = 3;
        for (Operation op : Operation.values()) {
            System.out.printf("%.1f %s %.1f = %.1f%n",
                x, op, y, op.apply(x, y));
        }

        // Enum 메서드
        Planet earth = Planet.valueOf("EARTH");
        System.out.println(earth.ordinal());  // 2 (0-based)
        System.out.println(earth.name());     // EARTH
    }
}

<?php
$langs = ['backend' => 'php', 'ml' => 'python'];

foreach ($langs as $key => $value) {
    echo "{$key}: {$value}
";
}

// 고차 함수 map
function add(a, b) {
  return a + b;
}
console.log(add(9, 2));

// 고차 함수 map
function add(a: number, b: number): number {
  return a + b;
}
console.log(add(9, 2));

// 고차 함수 map
using System;

int Add(int a, int b) => a + b;
Console.WriteLine(Add(9, 2));

// 고차 함수 map
#include <iostream>

int add(int a, int b) { return a + b; }
int main() {
    std::cout << add(9, 2) << "\n";
}

// 고차 함수 map
fn add(a: i32, b: i32) -> i32 { a + b }
fn main() {
    println!("{}", add(9, 2));
}