Grades

C'était la première fois que je participais. J'ai répondu correctement à ABC, mais j'étais frustré par le problème D. L'algorithme semble correct, mais je n'ai pas pu terminer le bogue. La performance est de 904.

Impressions

J'ai regardé diverses explications, mais je pense qu'il est important d'interpréter simplement le problème (correction de l'indice de 0, déplacement des coordonnées négatives en coordonnées positives avec des valeurs absolues, etc.). De plus, j'ai appris qu'il existe une méthode de solution qui les énumère toutes sans être particulière sur l'automatisation. Et la prochaine fois, je veux résoudre le problème D.

Problème A

--Ma réponse J'ai compté le nombre de Rs consécutifs

`A.py`



input_str = input()
cnt = 0
max_cnt = 0
for tmp in input_str:
    if tmp == "R":
        cnt +=1
        max_cnt = max(cnt, max_cnt)
    else:
        cnt = 0
        
print(max_cnt)

Énumération complète Il y a au plus 8 façons, il vaut donc mieux ne pas se soucier du débogage si vous les listez toutes. Référence: https://qiita.com/DaikiSuyama/items/c4ce6869cb897221bf8b

`A_.py`


s=input()
if s=="RRR":
    print(3)
elif s=="RRS" or s=="SRR":
    print(2)
elif s=="SSS":
    print(0)
else:
    print(1)

--Modèle En se concentrant uniquement sur R, il semble juger si cela s'applique à chaque motif continu. Référence: https://qiita.com/u2dayo/items/ce1b420344e451560b42

`A__.py`


s = input()
ans = 0

for i in range(1, 4):
    p = "R" * i
    if p in s:
        ans = i

print(ans)

Problème B

Je pense que les points étaient les suivants. (1) Dans plusieurs boucles, la valeur minimale de la boucle interne doit être la valeur du courant externe + 1. ② J'ai cherché sur Google parce que je ne connais pas les conditions du triangle

`B.py`


N = int(input())
input_list = list(map(int, input().split()))
pair_list = []
def triangle_check(a,b,c):
    return all([a+b>c, b+c>a, c+a>b, a!=b, b!=c,c!=a])
 
if N < 3:
    print(0)
else:
    for i in range(N):
        for j in range(i+1,N):
            for k in range(j+1,N):
                if triangle_check(input_list[i],input_list[j],input_list[k]):
                    pair_list.append([input_list[i],input_list[j],input_list[k]])
    print(len(pair_list))

Au fait, j'ai mal compris que c'était un problème plus avancé de ne compter que des paires uniques de combinaisons de longueurs, et j'ai perdu du temps. Dans ce cas, il a été implémenté à l'aide du code suivant. Référence: https://medium.com/@yamasaKit/2-python%E3%81%A7list%E3%81%AE%E4%B8%AD%E3%81%AElist%E3%82%92unique%E3%81 % AB% E3% 81% 99% E3% 82% 8B% E6% 96% B9% E6% B3% 95-f38d20e6674f

`del_list_dup.py`


duplicated_data = [tuple(d) for d in duplicated_data]
unique_data = set(duplicated_data)
unique_data = [list(d) for d in unique_data]

Problème C

Je pense que les points étaient les suivants.

--Valeur absolue de la valeur initiale X --Lorsque vous vous déplacez vers l'origine, vous avez ramifié selon que vous pouvez atteindre l'origine. --Si vous ne pouvez pas atteindre l'origine, rapprochez-vous le plus possible

Si vous pouvez l'atteindre, déplacez-le juste avant qu'il n'atteigne et déterminez combien de fois vous pouvez vous déplacer. --Si vous répétez autour de l'origine même fois, le mouvement sera annulé et ne changera pas de l'emplacement d'origine.
Dans le cas d'un nombre impair de fois, ce sera le dernier mouvement pour la raison ci-dessus.

`c.py`


X, K, D = list(map(int, input().split()))
X = abs(X)
syo, amari = divmod(X, D)
if amari > (D-amari):
    syo = syo +1
if syo >= K:
    print(X - K*D)
else: 
    remain_num = K - syo
    position = abs(X - syo*D)
    if remain_num%2 == 1:
        position = abs(position-D)
    print(position)

Problème D

(La réponse n'est pas correcte. Il y a un cas de test qui devient RE, nous allons donc corriger le bogue dès que le cas de test sera publié.) Je pense que les points étaient les suivants.

--Détection de boucle --Branch lorsque la valeur augmente et quand elle diminue pour chaque boucle --S'il descend pour chaque boucle, c'est une perte si vous répétez la boucle, alors trouvez la valeur maximale dans la première boucle --Si vous voulez monter pour chaque boucle, ajoutez le score de la boucle jusqu'à un avant la dernière boucle et la valeur maximale dans la section d'un avant la dernière boucle + la dernière boucle.

La raison pour laquelle la boucle précédente est placée dans la section de recherche de valeur maximale est que si vous bouclez avec un score tel que -1-> -2-> 100, et que la dernière boucle se termine -2 en raison de K, le dernier En effet, il vaut mieux finir avec 100, qui est un avant la boucle de. --L'index d'entrée commence à 1, mais il a été modifié pour commencer à 0 pour la commodité du programme.

`d.py`


import numpy as np
N,K = list(map(int, input().split()))
input_list = list(map(int, input().split()))
input_list = list(np.array(input_list)-1)
c_list = list(map(int, input().split()))
 
def roop_func(l, i, start, return_list=[]):
    return_list.append(l[i])
    if l[i] == start:
        return return_list 
    return roop_func(l, l[i],start, return_list)
 
total_best = -100000000000000000000
for start in range(N):
    p_list = roop_func(input_list, start, start,[])
    epoc = sum([c_list[i] for i in p_list])
    if epoc <= 0: #Quand ça tombe à chaque fois qu'il tourne
        best = c_list[p_list[0]]
        current_score = c_list[p_list[0]]
        for i in range(1, min(K, len(p_list))):
            current_score += c_list[p_list[i]]
            if best < current_score:
                best = current_score
    else: #Quand ça monte à chaque fois qu'il tourne
        syo,amari = divmod(K, len(p_list))
        base = (syo-1) * epoc
        tmp = p_list
        p_list.extend(p_list[:amari])
        tmp2 = p_list
        best = c_list[p_list[0]] + base
        current_score = c_list[p_list[0]] + base
        for i in range(1, len(p_list)):
            current_score += c_list[p_list[i]]
            if best < current_score:
                best = current_score
    if best > total_best:
        total_best = best
        
print(total_best)

[At Coder] Débutant Contest 175 Présentation de la solution ABCD python

Grades

Impressions

Problème A

A.py

A_.py

A__.py