_

[Python][투포인터] 연속된 부분수열의 합 (투포인터)

천숭이 — Fri, 1 Aug 2025 20:12:24 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/178870

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

프로그래머스 LV2 문제

정렬된 배열에서 부분 배열이 제시한 K와 같을 때 해당 인덱스를 반환. 단, 최소 개수의 부분 배열이여야 함.

def solution(sequence, k):
    answer = []
    left = 0 ; right = 0 ; index_num = len(sequeㄴㄴnce) # 최소 배열 체크용
    cnt = sequence[left]
    # sequence 는 정렬된 배열
    while 1 :
        #print ([left, right])
        if cnt == k :
            # 최소 배열인지 체크
            if index_num > right - left :
                index_num = right - left
                answer = [left, right]
            right += 1
            if right == len(sequence) : break
            cnt += sequence[right]
        elif cnt > k :
            cnt -= sequence[left]
            left += 1

        elif cnt < k :
            right += 1
            if right == len(sequence) : break
            cnt += sequence[right]

    return answer

아래 표처럼, 부분 배열의 합이 입력된 K보다 크거나 같을 경우에는 R ++

K보다 작을 때는 L--

이때 부분 배열의 합을 갱신해줘야 하기에,

L-- 이전에 합에서 [Left] 값을 빼주고, R++ 한 후에 합에서 [Right] 값을 더해주면서 전진하면됨

참고 : https://velog.io/@sugyeonghh/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EC%97%B0%EC%86%8D%EB%90%9C-%EB%B6%80%EB%B6%84-%EC%88%98%EC%97%B4%EC%9D%98-%ED%95%A9Python

자동차 통신 종류

천숭이 — Wed, 3 Apr 2024 11:47:10 +0900

자동차에 쓰이는 CAN FD 통신 종류

자동차에는 다양한 기능을 구현하기 위해 여러 종류의 CAN FD 통신이 사용됩니다. 주요 통신 종류와 특징은 다음과 같습니다.

1. Local CAN FD:

엔진, 변속기, ABS와 같은 차량 내부 통신에 사용됩니다.
높은 안정성과 짧은 지연 시간이 필요한 시스템에 적합합니다.
최대 속도는 5Mbps입니다.
데이터 길이는 최대 64바이트입니다.

2. B1-CAN FD:

ADAS, 인포테인먼트와 같은 차량 내부 및 외부 통신에 사용됩니다.
Local CAN FD보다 빠른 속도가 필요한 시스템에 적합합니다.
최대 속도는 10Mbps입니다.
데이터 길이는 최대 64바이트입니다.

3. R-CANFD (Remote CAN FD (Flexible Data-rate) ) :

차량 내부 및 외부 네트워크를 연결하는 통신 프로토콜입니다.
기존 CAN FD (Controller Area Network Flexible Data-rate) 기술을 기반으로 하며, 향상된 데이터 전송 속도, 안정성, 보안을 제공합니다.

4. CAN FD:

ADAS, 인포테인먼트, 전력망과 같은 차량 내부 및 외부 통신에 사용됩니다.
B1 CAN FD와 유사하지만, 5Mbps 속도도 지원합니다.
최대 속도는 5Mbps 또는 10Mbps입니다.
데이터 길이는 최대 64바이트입니다.

5. LIN (Local Interconnect Network) :

저렴하고 단순한 시스템 구현을 위해 개발된 차량 내부 네트워크 통신 프로토콜입니다.
엔진, 변속기, ABS와 같은 차량 내부 제어 시스템에서 센서, 액츄에이터, 스위치와 같은 저속 데이터 전송에 사용됩니다.

[Python] 스킬트리 - 프로그래머스 Lv2

천숭이 — Mon, 11 Dec 2023 16:29:36 +0900

"CBD"라는 스킬트리 skill이 주어진다. skill_trees의 스킬들은 skill 스킬트리의 순서를 무조건 따라야 하고, 선행 스킬을 무조건 진행해야 한다.

"CBADF"의 경우 중간 정해지지 않은 스킬이 들어가지만, CBD 순서대로 스킬을 완료했으므로 정답이다.

하지만 "BACDE"같은 경우에는 B가 C 스킬을 배우기도 전에 먼저 배우려고 해 정답이 아니다.

<알고리즘>

queue 자료구조를 활용해 스택을 구현할 것이다 (popleft 활용)

tree 스킬트리를 큐로 전환하고, 맨 앞인덱스가 skill에 포함되고 존재한다면 popleft로 삭제해준다.

하지만 skill에 포함되지 않는데 맨 앞 인덱스가 아니라면 선행스킬을 배우지 않고 먼저 나타난 것이기에 정답이 아니다.

이 때 위에서 설정한 is_tree를 False로 바꾸어주고,

그에 따라 answer 카운트업 여부를 결정해준다.

from collections import deque

def solution(skill, skill_trees):
    answer = 0

    for tree in skill_trees :
        is_tree = True
        q = deque(skill)
        for s in tree:
            if s not in q : continue
            if s == q[0] :
                q.popleft()

            else :
                is_tree = False

        if is_tree == True : answer += 1

    return answer
    
    
    
# ex ) solution("CBD", ["BACDE", "CBADF", "AECB", "BDA"])

[Python] 안전지대 - dfs, bfs로 풀기

천숭이 — Fri, 8 Dec 2023 23:58:30 +0900

출처 : 코드트리

문제 :

첫 번째 줄에는 과 이 공백을 사이에 두고 주어지고,

두 번째 줄부터는 개의 줄에 걸쳐 각 행에 위치한 개의 마을의 높이 정보가 공백을 사이에 두고 주어집니다.

k이하의 집들은 모두 물에 잠긴다고 한다. 물에 잠기지 않은 덩어리(?)들을 안전지대라고 한다면, 안전지대가 최대로 될 때의 k를 구하여라.

(집의 높이는 최대100, 따라서 빗물높이 k를 1부터 100까지 올리면서 구해야 한)

K 가 4일때 안전지대가 4로 최대인 모습

출력 :

이상의 중, 안전 영역의 수가 최대가 될때의 와 그 때의 안전 영역의 수를 공백을 사이에 두고 출력합니다. 만약 안전 영역의 수가 최대가 되는 가 여러 개라면, 그 중 가장 작은 를 출력합니다.

import sys
from collections import deque
sys.setrecursionlimit(2500)
n,m = map(int, sys.stdin.readline().split())

graph = [ list(map(int, sys.stdin.readline().split())) for _ in range(n) ]

def in_range(x, y):
    return 0<=x and x<n and 0<=y and y<m 

# k이하 숫자들에만 dfs 탐색 진행
def less_than_k(x,y,k):
    global K
    # 범위를 벗어남
    if not in_range(x,y) : 
        return False

    # 방문했거나 잠긴 집
    if graph[x][y] <= k or visited[x][y]==True : 
        return False

    return True

dx = [1,0,-1,0]
dy = [0,-1,0,1]
cnt = 0 
visited = [ [False]*m for _ in range(n) ]
def dfs(row, col, K):
    global cnt
    for i in range(4):
        new_row = row + dx[i]; new_col = col + dy[i]
        if in_range(new_row, new_col) == False : continue
        if less_than_k(new_row, new_col, K) == True :
            visited[new_row][new_col] = True
            dfs(new_row, new_col, K)


def bfs(x, y, K):
    global cnt
    q = deque()
    visited[x][y] = True
    q.append((x, y))
    while(q) :
        pop_x , pop_y = q.popleft()
        for i in range(4):
            new_row = pop_x + dx[i]; new_col = pop_y + dy[i]
            if in_range(new_row, new_col) == False : continue
            if less_than_k(new_row, new_col, K) == True :
                visited[new_row][new_col] = True
                q.append((new_row, new_col))


k_list = [0] * (101)
#모든지점에서 bfs 탐색 진행
# 잠긴곳은 False, 안잠긴 곳은 True
for KK in range(1, 101):
    visited = [ [False]*m for _ in range(n) ]
    cnt = 0

    for i in range(n):
        for j in range(m):
            if less_than_k(i,j,KK):
                visited[i][j] = True
                cnt+=1 # dfs하기 전에 cnt up
				
                #(1) bfs 방법 - 너비우선탐색
                bfs(i, j, KK)
                # (2) dfs 방법 - 깊이우선탐색
                # dfs(i,j,KK)

    k_list[KK] = cnt

visited[0][0] = True
ans = k_list.index(max(k_list))
if ans == 0 : ans = 1
print(ans, max(k_list))

파이썬 알면 좋은 내용!

천숭이 — Thu, 7 Dec 2023 16:56:39 +0900

1. 마름모 범위 체크

(↓마름모의 크기가 1일때)

	1
1	1	1
	1

위 격자에서 1이 있는 부분만을 마름모라고 표현한다면, (정사각형이고 한 변의 크기를 n이라고 하자)

(0,0) ~ (n-1,n-1) 즉, 좌측 위부터 우측 아래까지 모든 영역에서 (a,b)가 마름모의 범위에 속하는지 구하는 방법!

중앙의 인덱스 값을 (cx, cy)라고 한다면 아래 범위 내부에 속해야 한다.

|a-cx| + |b-cy| <= m (마름모의크기)

ex )

	1	?
1	1	1
	1

마름모 중앙의 인덱스는 (1, 1)이다. (0,2)가 범위 내에 있는지 체크해보자

|1-0| + |1-2| = 2이므로 범위 내에 없다

2. 다차원배열 -> 1차원배열

tmp = [[1,2],[3,4]]
result = sum(tmp, []) 
# tmp 내부의 리스트와 빈 리스트를 합친다는 의미로, 결국에 tmp 내부 리스트 값만 추출돼서 1차원배열로 저장됨

3. 격자에서 쓰면 좋은 스킬

(1) dx, dy 테크닉

(2) 빈 board를 만들어서 방문 체크

4. 사각형 시계방향으로 밀면서 회전

배열을 쉬프트해야 하는데, 행과 열이 증가하는 방향으로 쉬프트 되면 역순 for문으로 코딩하기

temp 한 번만 백업하는 방법!

# 직사각형 경계 숫자들 시계방향으로 회전
# 네 변 쉬프트 할 때마다 tmp 저장이 아닌, 한 번만 tmp 저장!
def rotate(start_row, start_col, end_row, end_col):
    temp = a[start_row][start_col]
    # 왼면
    for row in range(start_row, end_row):
        a[row][start_col] = a[row+1][start_col]
    
    # 아랫면
    for col in range(start_col, end_col):
        a[end_row][col] = a[end_row][col+1]

    # 오른면
    for row in rangee(end_col, start_col, -1)):
        a[start_row][col] = a[start_row][col-1]

    a[start_row][start_col+1] = temp

5. 파이썬 프로그램 종료 방법

# 프로그램 정상 종료
sys.exit(0)

# 프로그램 비정상 종료
sys.exit(1)

6. 리스트내에 반복되는 수열이 존재하는지, 그리고 바로 붙어서 존재하는지 체크

def is_possible_series():
    length = 1
    while True:
        # start2:end2 | start1:end1
        start1, end1 = len(series) - length, len(series) - 1
        start2, end2 = start1 - length, start1 - 1

        if start2 < 0:
            break

        # length만큼의 연속된 부분수열이 있는지 체크
        if series[start1:end1 + 1] == series[start2:end2 + 1]:
            return False

        length += 1
    
    return True

7. 문자열 받을 때 개행문자(줄바꿈 '\n') 처리 방법

readline 함수에서 strip() 처리 해주면 개행문자 제외되고 입력받을 수 있다

import sys
grid =[
    list(sys.stdin.readline().strip())
    for _ in range(n)
]

8. 격자 N X M 크기 헷갈릴 때

행 x 열 임을 기억하자.

통상 n은 행이고, m은 열로 표현

백준 문제 설명 중 일부

N x M = 3 x 5

9. recursion 깊이 제한 해제

sys.setrecursionlimit(2500)  # 2500 아닌 다른 수도 가능

STM32 개발 시, delay 함수 직접 구현해서 사용해보자 !

천숭이 — Wed, 6 Dec 2023 15:31:44 +0900

STM32F205RBT6 데이터시트를 참고하면

120 MHz 의 최대주파수로 동작하는 것을 확인 가능하다.

데이터시트 첫번째 장, Feature summary를 통해 빠르게 확인 가능

1us의 딜레이를 수행할 시 ,

asm("nop");  // CPU에게 아무런 작업도 하지 말라는 명령어

동작을 최대주파수만큼 실행한다

asm("nop")을 mcu의 주기만큼 작성하면 1us

만약 여러가지 통신과 기능이 구현되어 있다면, 스코프에서 확인하면 살짝의 오차가 발생하는 것을 확인할 수도 있다!

1us 를 구현했으니,

10us->100us ->1ms 까지 함수를 만들어 사용이 가능하다.

stm의 내장 딜레이 함수 사용하고 싶지 않을때, 만들면 좋다 !

Atmega로 UART, SPI 통신 구현

천숭이 — Mon, 4 Dec 2023 11:31:28 +0900

Atmega8A 칩을 사용해 UART, SPI 통신을 구현할 것입니다.

Atmega를 Master칩으로 설정하고, GPIO 핀을 활용해 연결된 Slave칩들의 핀들까지 컨트롤 할 것입니다.

따라서 코드를 그대로 적용할 시 작동이 안 될수도 있습니다,,!

그리고 데이터 시트에서 기초 통신 코드를 어셈블리코드와 C코드로 간략하게 기술되어 있습니다. 저도 그 코드를 일부 참고해서 작성했으니, 웬만하면 데이터시트를 먼저 참고해주세요 :>

< 데이터시트 참고해 SPI통신과 UART통신 설정>

1. SPI 설정

SPI통신에 필요한 네 개의 핀 확인

최소한의 기능으로 동작하기 위해서 라이브러리를 사용하지 않고, GPIO핀을 조작해 직접 SPI 구현할 것입니다.

SCK, MOSI, MISO, NSS 핀을 위 그림처럼 조작할 것입니다

- SPI_MasterInit() : 핀 설정

SCK, MOSI, NSS를 Output으로설정하고 MISO핀만 Input으로 설정합니다.

(내장라이브러리를 사용해 SPI를 구현할 것이면, SPCR |= (1<<SPE)|(1<<MSTR); 처럼 SPI 활성화 및 마스터설정을 해줘야 합니다.)

void SPI_MasterInit(void)  // GPIO
{
	// InOut Pin set
	DDRB |= (1<<SCK)|(1<<MOSI)|(1<<NSS);
	DDRB &= ~(1<<MISO); 
}

- SCK 핀을 1, 0으로 만들어주기 위한 매크로 구현

#define SCK_1		PORTB |= 1<<PORTB5;
#define SCK_0		PORTB &= ~(1<<PORTB5);

- SPI_Write() : addr 주소에 data 메모리 쓰기 구현

void SPI_WRITE(u8 addr, u8 data)
{
	u8 tmp;
	u8 mask = 0x80;  
    // MSB를 체크하며 1,0값을 핀에 실어서 보낸다
    // 왼쪽으로 쉬프트하면서 데이터를 스캔
	addr = (addr<<1)&0x7F;

	NSS_0  // SPI 통신 시작 - SCK핀에 따라서 동작 진행
    
    // SCK 핀을 올렸다 내렸다 8번 반복하며 MOSI 핀의 addr 데이터가 전송된다
	for (u8 i=0;i<8;i++)
	{
		if (addr & mask) {
			MOSI_1
		}
		else MOSI_0
		addr = addr<<1;
		SCK_1
		SCK_0
	}

	for (u8 i=0;i<8;i++)
    // SCK 핀을 올렸다 내렸다 8번 반복하며 MOSI 핀의 data 데이터가 전송된다
	{
		if (data & mask) {
			MOSI_1
		}
		else MOSI_0
		data = data<<1;
		SCK_1
		SCK_0
	}
    NSS_1

}

- SPI_READ()

u8 TRH_READ(u8 addr)
{
	u8 tmp;
    // MSB를 체크하며 1, 0값을 핀에 실어서 보낸다
    // 왼쪽으로 쉬프트하면서 데이터를 스캔
	u8 mask = 0x80;
	unsigned char result = 0;
	addr = (addr<<1)|0x80;

	NSS_0  // SPI 통신 시작 - SCK핀에 따라서 동작 진행
	for (u8 i=0;i<8;i++)
	{
		if (addr & mask) {
			MOSI_1
		}
		else {
			MOSI_0
		}
		addr = addr<<1;
		SCK_1
		SCK_0
	}
	
	for (u8 i=0;i<8;i++)
	{
		// 핀에 입력될때, result LSB += 1
		if(PINB & (0x10)) {  // INPUT = PIN!
			result += 0x01;
		}
		SCK_1
		SCK_0
		if (i != 7) result <<= 1;;
	}
	NSS_1
    
	return result;
}

2. UART 설정

UART는 데이터시트를 살펴보면 관련 레지스터가 있습니다.

- UBRRH (0x20) : Baud Rate 설정 레지스터

아래와 같이 설정하고자 하는 속도를 매크로로 정의했습니다.

#define BAUD 9600
#define MYUBRR FOSC/16/BAUD-1

- USART_Init() : 통신 속도 설정

초기화할때 설정한 MYUBRR을 매개로 실행합니다. -> USART_Init(MYUBRR);

void USART_Init(unsigned long baud)
{
	UBRRH = (unsigned char)(baud>>8);
	UBRRL = (unsigned char)baud;

	/* Enable receiver and transmitter */
	UCSRB = (1<<RXEN)|(1<<TXEN);
	/* Set frame format: 8data, 2stop bit */
	UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);	
}

- USART_Transmit() :

UCSRA라는 Status 레지스터를 통해 UDR 버퍼가 제대로 비워지고 채워졌는지 확인할 수 있습니다.

void USART_Transmit( unsigned char data )
{
	/* Wait for empty transmit buffer */
	while ( !( UCSRA & (1<<UDRE)) )
	/* Put data into buffer, sends the data */
	UDR = data;
}

Python 언어로 조합 구현! (combi함수안쓰고!)

천숭이 — Sun, 3 Dec 2023 21:30:11 +0900

입력 변수 n, arr

arr는 n*2개의 크기를 가지고 있다고 하자.

import sys
n = 2
arr = [1,2,3,4]

numbers = []
def print_combination(arr):
    for i in arr :
        print(i, end=' ')
    print()

# curr_idx : 탐색의 정도, 배열을 모두 탐색했을 때 종료해야 하므로
# curr_idx == 배열의 크기   가 재귀함수의 종료조건. (성공/실패 모두 포함)
# 그리고 선택된 배열의 크기를 나타내는 cnt -> numbers 배열에 append 할 때마다 cnt+1 되고 있으므로.
# 따라서 cnt의 크기는 몇 개를 선택했느냐, 조합 선택 여부를 살펴보는 조건. (성공일때만)
def make_combination(curr_idx, cnt):
    # 종료 조건
    if curr_idx == 2*n:
        # 조합 완성되는 조건
        if cnt == 2:
            print_combination(numbers)
        return

    numbers.append(arr[curr_idx])
    make_combination(curr_idx+1, cnt+1)
    numbers.pop()
    make_combination(curr_idx+1, cnt)

make_combination(0,0)

주석 참고 :)

n = 3
def find_min(color, cnt):
    if color == n :
        if cnt==n-1 :
            print(numbers)
        return

    numbers.append(color)
    find_min(color+1, cnt+1)
    numbers.pop()
    find_min(color+1, cnt)

find_min(0, 0)

출력 :

[0, 1]
[0, 2]
[1, 2]

[Python] 백준 1926 그림 - bfs알고리즘

천숭이 — Wed, 29 Nov 2023 00:10:47 +0900

참고 : https://www.youtube.com/watch?v=ansd5B27uJM

예제 입출력

from collections import deque
import sys

input = sys.stdin.readline

# 세로, 가로
n,m = map(int, input().split())
map = [list(map(int, input().split())) for _ in range(n)]

# 방문횟수 - 가로m개인 false리스트가 세로로 n개 있어야함
chk = [[False]*m for _ in range(n)]

# dy, dx는 그냥 외우기 - 좌표 이동에 사용됨
dy = [0,1,0,-1]
dx = [1,0,-1,0]

def bfs(y, x) :
    rs = 1
    q = deque()
    q.append((y,x))
    while q:
        ey, ex = q.popleft()
        for k in range(4):
            ny = ey + dy[k]
            nx = ex + dx[k]
            if (0<=ny and ny<n) and (0<=nx and nx<m):
                if map[ny][nx] == 1 and chk[ny][nx] == False:
                    rs += 1
                    chk[ny][nx] = True
                    q.append((ny, nx))

    return rs


cnt = 0 # result
maxv = 0 # 가장 큰 지도
for j in range(n) :
    for i in range(m):
        if map[j][i] == 1 and chk[j][i] == False:
            chk[j][i] = True
            cnt += 1
            maxv = max(maxv, bfs(j,i))
            # 전체 그림 갯수 +1
            # BFS > 그림 크기를 구해주고
            # 최대값 갱신

print(cnt)
print(maxv)

코드 분석!

- 큐 자료구조를 사용하므로 deque 선언

- sys 라이브러리로 input 시간을 간소화 시킬 것임

from collections import deque
import sys

- 세로, 가로를 입력받아주고 int 자료형으로 매핑시켜준다

- 입력 형태를 리스트 2중 리스트 구조로 만들어 줄 것 (컴프리헨션 작성법 잘 익혀두기!)

- 한 행 입력받은것을 split해서 input으로 매핑시키고, 그 한 줄을 리스트로 저장하는데 이 동작을 n번 반복

* map의 형태 : [[1, 1, 0, 1, 1], [0, 1, 1, 0, 0], [0, 0, 0, 0, 0], [1, 0, 1, 1, 1], [0, 0, 1, 1, 1], [0, 0, 1, 1, 1]]

- chk도 이중 리스트구조이며, 방문체크를 위해 만든 리스트, 'False' 로 m개 채워진 리스트를 n개 만든다

# 세로, 가로
n,m = map(int, input().split())
map = [list(map(int, input().split())) for _ in range(n)]

# 방문횟수 - 가로m개인 false리스트가 세로로 n개 있어야함
chk = [[False]*m for _ in range(n)]

- bfs 함수를 호출하는 main 부분

- cnt 는 그림의 개수, maxv는 지도의 최대 크기

- 이중포문은 보통 바깥 y, 내부 x포문으로 이루어져 있다 (바깥 세로, 내부 가로)

이중포문 진입

- map의 [j][i] 인덱스가 1이고(그림영역이고) chk의 [j][i] 인덱스가 False이면(방문하지 않았다면), 지도개수 +=1

- 이 때, 방문 체크

- bfs 알고리즘을 이용해 지도의 최대 크기도 구해보자.

cnt = 0 # result
maxv = 0 # 가장 큰 지도
for j in range(n) :
    for i in range(m):
        if map[j][i] == 1 and chk[j][i] == False:
            chk[j][i] = True
            cnt += 1
            maxv = max(maxv, bfs(j,i))
            # 전체 그림 갯수 +1
            # BFS > 그림 크기를 구해주고
            # 최대값 갱신

print(cnt)
print(maxv)

bfs 알고리즘 함수설명

- 좌표를 상,하,좌,우 이동하면서 체크해야 하기에 dy와 dx 선언과 그 용법은 암기해두는 것이 편하다

- q를 queue 자료구조로 선언해주고 매개변수 y,x를 저장해준다.

- y,x를 저장해주면서 while문이 살아있

# dy, dx는 그냥 외우기 - 좌표 이동에 사용됨
dy = [0,1,0,-1]
dx = [1,0,-1,0]

def bfs(y, x) :
    rs = 1
    q = deque()
    q.append((y,x))
    while q:
        ey, ex = q.popleft()
        for k in range(4):
            ny = ey + dy[k]
            nx = ex + dx[k]
            if (0<=ny and ny<n) and (0<=nx and nx<m):
                if map[ny][nx] == 1 and chk[ny][nx] == False:
                    rs += 1
                    chk[ny][nx] = True
                    q.append((ny, nx))

    return rs

[Python] 지그재그로 숫자 채우기 (이중배열)

천숭이 — Wed, 29 Nov 2023 00:07:52 +0900

출처 : 코드트리

n * m크기의 직사각형에 숫자를 0부터 순서대로 1씩 증가시키며 왼쪽 위에서부터 시작하여 다음과 같이 지그재그 모양으로 숫자들을 쭉 채우는 코드를 작성해보세요.

import sys
a, b = map(int,sys.stdin.readline().split())  # 행, 열

buf = [[0]*b for _ in range(a)]

count=0

for col in range(b):  # 열
    if col % 2 == 0:  # 짝수열이면
        for row in range(a):
            buf[row][col] = count
            count += 1
    else:             # 홀수열이면
        for row in range(a-1, -1, -1):   # 0~n-1까지 역순으로
            buf[row][col] = count
            count+=1

for row in range(a):
    for col in range(b):
        print(buf[row][col], end=' ')
    print()

간단하게 알고리즘 짜는 연습이 필요!

그림처럼 홀수열은 밑으로 채워나가고,

짝수열은 밑에서 채워 올라간다.

따라서 짝수열일때만 역 for문을 사용해서 변수를 채워주면 된다.