코테 대비 루비 문법 공부하기!

변수명 선언

# 파이썬과 비슷하게 세미콜론 없습니다.

# 로컬변수 : 소문자로 작성
apple="로컬"

# 인스턴스 변수 : 변수명 앞에 @
@apple="인스턴스"

# 클래스 변수 : 변수명 앞에 @@
# @@apple="클래스"

# 글로벌 변수 : 변수명 앞에 $
$apple="글로벌"

# 상수 : 대문자로 작성
APPLE="상수"


puts @apple
puts $apple
puts apple
puts APPLE

 

주석 처리

# 한 줄 주석처리는 이렇게 합니다. 
=begin 
  Ruby에서는 여러주석은 bigin end를 활용해
  처리를 합니다.
=end

 

입력

# # 기본적인 입력값
name= gets
puts "안녕하세요, #{name}님!"

# # 입력값에서 개행 문자 제거 chomp
name = gets.chomp
puts "안녕하세요, #{name}님!"

# # 정수 입력 실수는 f
age= gets.chomp.to_i
puts "나이:" #{age} 

# puts "숫자 3개를 입력하세요 (공백으로 구분):"
numbers = gets.chomp.split.map(&:to_i)
puts "입력된 숫자: #{numbers.inspect}"

# 여러 공백 1 2 3 이런거 
# 방법 1
a, b, c = gets.chomp.split.map(&:to_i)
# 방법 2
a, b, c = gets.chomp.split
puts a 
puts b

# 문자열 -> 배열
message = gets.chomp.to_s
stack=[]
message.each_char {|element| stack.push(element)}

# 이렇게 바로 해도됨
left_stack=gets.chomp.chars

# 숫자 -> 배열
message = gets.chomp.chars.map(&:to_i)
stack = message.digits.reverse

 

출력

apple="나는 사과"

print apple

puts apple

p "123"
p 123

puts answerHeart.join(" ")
puts answer.join(" ")
# 이렇게 하면 0 0 0 0 0 이렇게 출력됨 참고로 저건 배열 및 리스트

puts [a,b].join(" ")
 puts "#{min} #{max}"
 
 
 # 20개씩 출력 한줄에 
 BUTTON.each_slice(20) { |slice| puts slice.join(" ") }

 

연산 비교

puts 5<=>4
puts 5<=>6
puts 5<=>5

=begin
이 연산자는 두 값을 비교하고 결과를 다음 값 중 하나로 반환합니다:

-1: 왼쪽 값이 오른쪽 값보다 작을 때
0: 왼쪽 값이 오른쪽 값과 같을 때
1: 왼쪽 값이 오른쪽 값보다 클 때

추가로 == 이거는 값 === 이거는 타입이 같을때를 말한다. 
=end

 

조건문

apple=3
num=3

if apple < num
  puts "웅"
elsif apple > num  
  puts "아닝"
else 
  puts "zzz"
end

# end는 필수다!!!!

 

반복문

# 강추!!
5.times { |i| puts "반복 횟수: #{i}" }

# for 문 여기서 ...이 3개이면 -1 적용 즉 아래는 1 2 3 4 5 지만 1 2 3 4 가됨
for i in 1..5
  puts "for"
end

# while 문
count=0
while count < 5
  puts "while"
  count+=1 # 루비는 ++ 이런거 없음
end

# 리스트 순회는 이렇게 each 사용해서 아니면 for문 사용해서 해두됨 

array=[1,2,3,4,5]

array.each do |nc|
  puts nc 
end

array.each_with_index do |nc, index|
  puts "#{index}: #{nc}"
end



# 문자열 순회 배열이랑 다름!
message.each_char do |char|
end

# 문자열 인덱스도 알기 위해
S.each_char.with_index do |char, i|
end


# N은 무조건 숫자
N.times do |i|
  name[i] = gets.chomp.to_s
end

# 배숫씩 증가
 for i in (number..N).step(number)
 
 # 단계 줄이기
 for j in (number - 1).step(1, -1)

응용

arr=[]

# 입력
row, col=gets.chomp.split.map(&:to_i)

row.times do
  data=gets.chomp.split.map(&:to_i)
  arr << data
end

# 전체 배열 보기
arr.each { |row| puts row.inspect }


# 따로 출력 
arr.each do |row|
  row.each do |value|
    print value, " "
  end
  puts
end

 

배열 응용  

arr= [1, 2, 3]

# 배열 초기화 
alphabet = Array.new(26, false)

# 입력
arr << 4
arr.push(5)

# 맨앞에 추가 unshif
arr.unshift(1)

# 마지막 요소 제거하고 반환
back=arr.pop

# 첫번째 요소 제거하고 반환
front=arr.shift

# 특정 요소 삭제 즉 2인것들 다 제거 
arr.delete(2)

# 특정 위치 요소 삭제 2번쨰 자리 제거
arr.delete_at(2)

# 값 경신 
arr[2]=10

# 특정 값 찾기 즉 2를 찾으면 2의 위치가 나옴  
index_of arr.index(2)

# 오름차순 및 내림차순 ! 붙이면 원본 바뀜
arr1=arr.sort!
arr2=arr.sort.reverse

# 거꾸로 순서 ! 붙이면 원본 바뀜
arr3= arr.reverse

# 깊은 복사
copy = arr.dup

# 배열 크기 및 사이즈 
m=arr.size 
m=arr.length

#비웠냐
left_stack.empty?
# 중복 요소 제거
uniq2= arr.uniq

# 특정 요소 포함
array = [1, 2, 3]
puts array.include?(2)   # true

# 특정영역 넣기 리스트 및 문자열 동일
stack.insert(cursor, view[1])

# 중복제거
def remove_duplicates(arr)
  arr.uniq
end

# 어떤게 더 많이 있나
arr=["apple", "banana", "apple", "orange", "banana", "apple"]
integer = arr.max_by { |e| arr.count(e) }


# 배열 요소 중 큰값 
arr = [3, 1, 4, 1, 5, 9, 2, 6, 5]
puts arr.max 

# 이중 배열일떄 큰값
queue.push([num, j]) 
max_priority = queue.map { |q| q[0] }.max


# 위치 답1
arr=[1,2,3]
puts arr.index(2)

 

 

해쉬 셋

hash = { "name" => "Alice", "age" => 25 }

# 값 접근
puts hash["name"]  # 출력: Alice

# 값 추가
hash["city"] = "Seoul"

puts hash.inspect  # 출력: {"name"=>"Alice", "age"=>25, "city"=>"Seoul"}


require 'set'

set = Set.new([1, 2, 2, 3])
puts set.inspect  # 출력: #<Set: {1, 2, 3}>

# 값 추가
set.add(4)
puts set.inspect  # 출력: #<Set: {1, 2, 3, 4}>

# 값 포함 여부 확인
puts set.include?(2)  # 출력: true
puts set.include?(5)  # 출력: false

# 값 삭제
set.delete(3)
puts set.inspect  # 출력: #<Set: {1, 2, 4}>

 

날짜

require 'date'

today = Date.today
puts today  # 출력: 2025-01-23 (현재 날짜)

birthday = Date.new(1995, 5, 12)
puts birthday  # 출력: 1995-05-12

 

 

메서드

def greet(name)
  puts "Hello, #{name}!"
end

greet("Alice")  # 출력: Hello, Alice!
greet("Bob")    # 출력: Hello, Bob!


def add(a, b)
  return a + b
end

puts add(2, 3)  # 출력: 5



def abcd(i,message)
  puts i
  puts message
  puts "a"
  return "오케이"
end
a=""

5.times { a = abcd(3, "g")
}

puts a

abcd(3,"g")

 

 

수학 함수

a = 10
b = 20
max_value = [a, b].max
puts max_value  # 20


numbers = [5, 15, 25, 10]
max_value = numbers.max
puts max_value  # 25

puts (-10).abs     # 출력: 10
puts 5.abs         # 출력: 5
puts (-3.14).abs   # 출력: 3.14


#최대 최소
min_length = Float::INFINITY
max_length = -Float::INFINITY

 

아스키 코드 

# 자바랑 다르게 ord chr 이용해서 해결해야됨!
message=['a','b']

place = message[0].ord

word=(place+1).chr
puts word

 

문자 

message="gggg"

# trim 앞 뒤 공백제거
message.strip

# 대문자
message.upcase

# 소문자
message.downcase

# 문자가져오기
message.slice(1,3)

# 문자 특정 위치 바꾸기
message[0]='g'
message[0,2]="dd"

# 숮자 및 문자열 변환
num=1 
num.to_s
num.to_i


# 특정 문자 인덱스참고로 r은 마지막 index는 그냥 처음 
index = input.index('*')
index = input.rindex('*')

# 특정 문자 갯수  
count = input.count('*')

 

응용2

('a'..'z').each do |char|
    position = []


# 문자열 돌리기 
 message.chars.each_with_index do |mess, index|
   position << index if mess == char
 end
 
 
 # 해쉬 생성
 positions = Hash.new { |h, k| h[k] = [] }  

  # 각 문자의 등장 인덱스를 저장
  message.chars.each_with_index do |char, idx|
    positions[char] << idx
  end


  # 해쉬 탐색 a: char, [1,3,4]: indices
  positions.each do |char, indices|

 

스택

N = gets.chomp.to_i

stack = []
N.times do
  message = gets.chomp.split.map(&:to_s)

  case message[0]
  when "push"
    stack.push(message[1].to_i)

  when "pop"
    num = stack.pop
    if num == nil
      puts -1
    else
      puts num
    end
  when "size"
    puts stack.size
  when "empty"
    if stack.empty?
      puts 1
    else
      puts 0
    end
  when "top"
    if stack.size == 0
      puts -1
    else
      puts stack.last
    end
  end
end

 

큐

N=gets.chomp.to_i

queue=[]

N.times do
  message=gets.chomp.split.map(&:to_s)

  case message[0]
  when "push"
    queue.push(message[1].to_i)
  when "pop"
    num = queue.shift
    if num == nil
      puts -1
    else
      puts num
    end
  when "size"

    puts queue.size
  when "empty"
    if queue.empty?
      puts 1
    else
      puts 0
    end
  when "front"
    if !queue.empty?
      puts queue.first
    else
      puts -1
    end
  when "back"
    if !queue.empty?
      puts queue.last
    else
      puts -1
    end
  end
end


# 이중 배열일떄
index = input.rindex('*')

 

객체

class Car
  attr_accessor :id, :name  # 자동으로 getter와 setter 생성

  def initialize(id = nil, name = nil)
    @id = id
    @name = name
  end
end

car = Car.new("1","기")  # new 키워드는 클래스명 뒤에 직접 사용
car.id = "123"  # setId에 해당
car.name="승호"
puts car.name   # getName에 해당