introduction

J'ai commencé AtCoder avec Ruby. C'était amusant et addictif, et c'est le moment où j'ai réalisé le plaisir de la programmation du fond de mon cœur.

Eh bien, je ne suis pas un programmeur, Voici quelques conseils à connaître pour vous familiariser avec AtCoder. Je pense que vous pouvez réussir à vous battre en défiant AtCoder en référence à ce qui suit.

En étudiant les algorithmes d'AtCoder J'espère qu'il transmet le plaisir de Ruby et le plaisir de la programmation.

Je peux résoudre A et B normalement, et parfois C peut être résolu, Si vous regardez ce qui suit et que vous l'appliquez, ce sera probablement au même niveau. ..

Sauf pour les algorithmes et formules mystérieux Les bases sont toutes les applications suivantes.

Fractionner la chaîne de caractères saisie (exemple d'échec)

gets.split('')
aaa
=> ["a", "a", "a", "\n"]

/ n est inclus.

Fractionner la chaîne de caractères saisie (exemple de réussite)

gets.chomp.split('')
aaa
=> ["a", "a", "a"]

J'ai pu le diviser en une sensation agréable en insérant du chomp.

Comment saisir des nombres (exemple d'échec)

gets.chomp
1
=> "1"

L'entrée est une chaîne de caractères.

Comment saisir des nombres (exemple de réussite)

gets.to_i
1
=> 1

gets est saisi sous forme de chaîne.

Comment entrer un tableau numéroté a

gets.split.map(&:to_i)
1 2 3
=> [1, 2, 3]

Veuillez entrer un espace pour chaque numéro.

Comment créer plusieurs séquences imbriquées

3.times.map{gets.split.map(&:to_i)}
1 2 3
1 2 3
1 2 3
=> [[1, 2, 3], [1, 2, 3], [1, 2, 3]]

Vous avez maintenant un tableau imbriqué avec plusieurs nombres.

Une méthode d'entrée + comment la répéter N fois pour créer un tableau de valeurs d'entrée

N = gets.to_i
3
=> 3
b = N.times.map{gets.to_i}
1
2
3
=> [1, 2, 3]

Comment déterminer s'il est pair ou impair

a = 2
=> 2

a.even?
=> true

a.odd?
=> false

Déterminez si même? Odd? Détermine si c'est impair.

Vérifiez la longueur de la variable

a = "aaaa"
=> "aaaa"

a.size
=> 4

a.length
=> 4

a = [1,2]
=> [1, 2]

a.size
=> 2

a.length
=> 2

la taille et la longueur sont les mêmes. Vous pouvez également organiser des chaînes.

Obtenez la valeur absolue d'un nombre

a = -10
=> -10

a
=> -10

a.abs
=> 10

Ecrire un opérateur ternaire

if true 
  puts "Yes"
else 
  puts "No"
end

#Ce qui précède peut être écrit sur une seule ligne
puts true ? "Yes": "No"

Ceci est souvent vu dans la question A, alors souvenez-vous-en!

Sortie des valeurs maximum et minimum dans le tableau

a = [0, 1 ,2, 3]
=> [0, 1, 2, 3]

 a.min
=> 0

a.max
=> 3

Éliminez les doublons dans le tableau

 a = [1, 1, 2, 2, 3]
=> [1, 1, 2, 2, 3]

a.uniq
=> [1, 2, 3]

Sortie de la valeur totale dans le tableau

a = [1, 1, 2, 2, 3]
=> [1, 1, 2, 2, 3]

 a.sum
=> 9

a.inject(:+)
=> 9

#Remarques: La multiplication est la suivante
a.inject(:*)
=> 12

Soit la somme, soit l'injection, c'est bien. S'il s'agit de la série Ruby2.3.3, vous ne pourrez peut-être pas utiliser sum!

Ajouter à la fin du tableau

 a = []
=> []

 a << 1
=> [1]

 a << 2
=> [1, 2]

a << 3
=> [1, 2, 3]

Supprimer la fin du tableau

a = [1,2,3]
=> [1, 2, 3]

a.delete_at(-1)
=> 3

a
=> [1, 2]

Pratique car vous pouvez spécifier la position de n'importe quel tableau

Supprimer le nombre spécifié dans le tableau

 a = [1,2,3]
=> [1, 2, 3]

a.delete(1)
=> 1

a
=> [2, 3]

a = [1,1,2,3]
=> [1, 1, 2, 3]

 a.delete(1)
=> 1

a
=> [2, 3]

Je l'ai écrit différemment de delete_at, Il peut être rare de supprimer le numéro spécifié Je vois souvent la suppression des doublons à l'aide d'uniq

Spécifiez la fin du tableau

 a = [1, 1, 2, 2, 3]
=> [1, 1, 2, 2, 3]

 a[-1]
=> 3

Récupère un tableau de nombres spécifiés


#Sortez le 5
n = 5
=> 5

a = [1, 1, 2, 2, 3]
=> [1, 1, 2, 2, 3]

a[n]
=> nil

a[n - 1]
=> 3

Le tableau commence à 0, vous devez donc -1.

Quitter la boucle lorsque la valeur du tableau est atteinte

a = [1, 2, 3, 4]

a.each do |i|
  if i == 2
    puts i
    break
  end
end

À propos, la différence entre Break et Return est de savoir s'il faut sortir de la boucle ou de la méthode. Le retour ne peut être utilisé qu'à l'intérieur d'une méthode.

Comment renvoyer true lorsque tous les éléments du tableau sont vrais

a = [2,2,2,2]
=> [2, 2, 2, 2]

a.all?{|n| n.even?}
=> true

 a
=> [2, 2, 2, 2]

a.all?{|n| n == 2}
=> true

a = [2,2,2,3]
=> [2, 2, 2, 3]

a.all?{|n| n == 2}
=> false

Renvoie true car tous les éléments du tableau sont pairs.

Trier le tableau + passer de croissant à décroissant

a = [3,1,2]
=> [3, 1, 2]

a.sort
=> [1, 2, 3]

a.sort.reverse
=> [3, 2, 1]

#Au fait, les chaînes de caractères du tableau. ..

a = [ "aaa", "ccc","bbb"]
=> ["aaa", "ccc", "bbb"]

a.sort
=> ["aaa", "bbb", "ccc"]

a.sort.reverse
=> ["ccc", "bbb", "aaa"]

Voir beaucoup

Supprimer le premier élément du tableau

a = [5,6,7]
=> [5, 6, 7]

 a.drop(1)
=> [6, 7]

#Cela ne semble pas destructeur.
 a
=> [5, 6, 7]

 a.drop(1)
=> [6, 7]

a.drop(2)
=> [7]

a.drop(3)
=> []

la goutte ne semble pas destructrice

Extraire le premier élément du tableau

a[0]
=> 5

a.shift
=> 5

#↑ Pareil?

a = [5,6,7]
=> [5, 6, 7]

a.shift
=> 5

a.shift
=> 6

a.shift
=> 7

a = [5,6,7]
=> [5, 6, 7]

 a[0]
=> 5

a[0]
=> 5

le changement semble destructeur. Je pensais que c'était la même chose.

Comment compter à une certaine valeur

a = [1, 2, 3, 4]

count = 0

a.each do |i|
  if i == 1
    count += 1
  end
end

puts count

=>1

Branche conditionnelle lorsqu'elle est divisible par une certaine valeur

k = 2
a, b = [1, 3]

(a..b).each do |c|
  if c % k == 0
    puts  'OK'
    break
  end

  if c == b
    puts 'NG'
  end
end

Comment continuer à boucler jusqu'à ce que vrai

x = 2
yen = 100
count = 0

while yen > x do
  yen += yen / 100
  count = count + 1
end

puts count

While bouclera tant que cela reste vrai. Tu n'as pas besoin d'une expression conditionnelle Si vous voulez quitter et quitter, utilisez loop do ... end! Bien sûr, même si c'est vrai ... la fin est bien.

Joindre des tableaux dans une chaîne

a = ["a", "b", "c", "d"]
=> ["a", "b", "c", "d"]

 a.join
=> "abcd"

Découvrez le nombre de caractères spécifiés après avoir joint les tableaux dans une chaîne

 a = ["a","b","a","b","a"]
=> ["a", "b", "a", "b", "a"]

a.join
=> "ababa"

a.join.scan("ab")
=> ["ab", "ab"]

#plus loin"ab"Retirez le nombre de.
a.join.scan("ab").length
=> 2

Il semble que le scan puisse être très bien utilisé. ..

Spécifiez le contenu et l'index du bloc de tableau (valeur qui se répète à chaque fois)

c = gets.chomp

alf = []
("a".."z").each do |i|
  alf << i
end

#Spécifiez le contenu et l'index du tableau sous forme de blocs
alf.each_with_index do |k, i|
  if k == c
    puts alf[i+1]
    break
  end
end

Si seulement k est utilisé, le contenu du tableau "a", "b" ... "z" sera extrait. Vous ne pouvez pas spécifier d'index, non? each.with.Utilisation de l'index|k, i|Puis Vous pouvez spécifier l'index du tableau dans i. C'est 0 dans alf [0]. Le contenu du tableau réel est k.

Comment créer un tableau unidimensionnel ou bidimensionnel

a = Array.new(3)
=> [nil, nil, nil]

a = Array.new(3).map{Array.new(3, 0)}
=> [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

a[0][1] = 1
=> 1

 a
=> [[0, 1, 0], [0, 0, 0], [0, 0, 0]]

 a[2][1] = 1
=> 1

 a
=> [[0, 1, 0], [0, 0, 0], [0, 1, 0]]

a[2][0] = 1
=> 1

a
=> [[0, 1, 0], [0, 0, 0], [1, 1, 0]]

C'est compliqué quand il s'agit de deux dimensions

Répétez une chaîne plusieurs fois.

a = 2
=> 2

b = 3
=> 3

a.to_s * b
=> "222"

L'entrée de a saisi sous forme de nombre est convertie en chaîne de caractères et b est répétée 3 fois.

Tronquer, arrondir, arrondir les nombres

a = 1.4
=> 1.4

a.floor
=> 1

 a.ceil
=> 2

a.round
=> 1

a =1.5
=> 1.5

a.floor
=> 1

a.ceil
=> 2

a.round
=> 2

Engagements maximum et minimum de nombres

#Engagement maximum
4.gcd(2)
=> 2

4.gcd(4)
=> 4

4.gcd(6)
=> 2


#Multiple commun minimum
 4.lcm(2)
=> 4

4.lcm(4)
=> 4


4.lcm(6)
=> 12

Que ce soit pour sortir avec put, p ou imprimer

Pour conclure d'abord, les puts sont bons. La réponse ne correspond pas car p a "".

a = "aaa"
=> "aaa"

p a
"aaa"
=> "aaa"


 puts a
aaa
=> nil


 print a
aaa=> nil

Obtenir l'index de la valeur qui est la méthode d'index

#Chaîne
a = ["3","4"]
=> ["3", "4"]

 a
=> ["3", "4"]

a.index("3")
=> 0

a.index("4")
=> 1

application

Multiplication des tableaux

n = gets.to_i
a = gets.split.map(&:to_i)
sum = 1

#En gros, tournez avec chacun, mais notez qu'il y a 0 dans la multiplication
a.each do |i|
  if i == 0
    sum = 0
    break
  end

#Somme pour les grands nombres<=Faisons 〇〇!
  sum *= i if sum <= 〇〇
end

Utilisez to_d car une erreur se produira si to_f est utilisé comme point décimal.

require 'bigdecimal'
require 'bigdecimal/util'

l = gets.chomp.split(" ")
a = l[0].to_i
#to_Il semble qu'une erreur se produira si elle est définie sur f
#La réponse peut ne pas correspondre.
b = l[1].to_d

puts (b * a).floor

Faire la factorisation principale

require 'prime'

a = 100
=> 100

 n = a.prime_division
=> [[2, 2], [5, 2]]

#[[2, 2], [5, 2]]Est"(2**2) * (5**2) = 100"Cela signifie

#Puisqu'il s'agit d'un tableau à deux dimensions, spécifiez deux éléments
n.each do |i, k|
  puts i
  puts k
end

2
2
5
2
=> [[2, 2], [5, 2]]

Obtenir tous les modèles dans un tableau (ordre)

 n = 3
=> 3

a = [1,2,3]
=> [1, 2, 3]

a.permutation(n).to_a
=> [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

Très pratique!

Supprimer le caractère spécifié dans la chaîne de caractères plusieurs fois

n = "testrestdest"
=> "testrestdest"

a
=> ["test", "rest", "pest", "dest"]

a.each do |i|
  n.gsub!(/#{i}/, '')
end

n
=> ""

Tout a disparu C'est destructeur avec gsub!.

Résolvez sans chercher dans le tableau

#Atcoder149B
#https://atcoder.jp/contests/abc149/tasks/abc149_b

a,b,k = gets.chomp.split.map(&:to_i)

k.times do
  if a >= 1
    a = a - 1
   elsif b >= 1
    b = b- 1
   elsif a = 0 && b = 0
  end
end
puts "#{a} #{b}"
#Temps écoulé

a, b, k = gets.split().map(&:to_i)
if a >= k
  puts "#{a-k} #{b}"
elsif a+b <= k
  puts "#{0} #{0}"
else
  puts "#{0} #{b-(k-a)}"
end
#OK

Soyez conscient des nombres absolus lorsque vous êtes sur une ligne droite!

a et b sont les premières coordonnées

a = 1
=> 1

a = -2
=> -2

 a - b
=> -5

(a - b).abs
=> 5

Une valeur qui revient à la position d'origine à partir de la valeur d'entrée [angle] dans une fonction linéaire

x = gets.to_i

puts 360.lcm(x) / x

Si le nombre est divisible par 360 degrés, vous pouvez le diviser normalement, Si la valeur n'est pas divisible par 360 degrés, recherchez le multiple commun minimum de 360 degrés. Il semble que vous deviez le casser.

[Débutant] Résolvons le problème d'AtCoder avec Ruby en regardant l'article!