[At Coder] Anfängerwettbewerb 175 Einführung in die ABCD-Python-Lösung
Noten
Ich habe zum ersten Mal teilgenommen.
Ich habe ABC richtig beantwortet, aber das D-Problem hat mich frustriert.
Der Algorithmus scheint korrekt zu sein, aber ich konnte den Fehler nicht bis zum Ende bringen.
Die Leistung beträgt 904.
Impressionen
Ich habe mir verschiedene Erklärungen angesehen, aber ich denke, es ist wichtig, das Problem einfach zu interpretieren (den Index von 0 zu korrigieren, negative Koordinaten in positive Koordinaten mit absoluten Werten zu verschieben usw.). Außerdem habe ich gelernt, dass es eine Lösungsmethode gibt, die alle auflistet, ohne sich speziell mit Automatisierung zu befassen. Und das nächste Mal möchte ich das D-Problem lösen.
Problem A
--Meine Antwort Ich habe die Anzahl der aufeinanderfolgenden Rs gezählt
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)
- Vollständige Aufzählung Es gibt höchstens 8 Möglichkeiten, daher ist es besser, sich nicht mit dem Debuggen zu beschäftigen, wenn Sie alle auflisten. Referenz: 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)
--Muster Wenn man sich nur auf R konzentriert, scheint es zu beurteilen, ob es für jedes kontinuierliche Muster gilt. Referenz: 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)
B-Problem
Ich denke, die Punkte waren wie folgt. (1) In mehreren Schleifen sollte der Mindestwert der inneren Schleife der äußere Stromwert + 1 sein. ② Ich habe gegoogelt, weil ich die Bedingungen des Dreiecks nicht kenne
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))
Übrigens habe ich falsch verstanden, dass es ein fortgeschritteneres Problem war, nur eindeutige Paare von Längenkombinationen zu zählen, und ich habe Zeit verloren. In diesem Fall wurde es mit dem folgenden Code implementiert. Referenz: 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]
C-Problem
Ich denke, die Punkte waren wie folgt.
- Absoluter Wert des Anfangswertes X.
- Wenn Sie sich dem Ursprung nähern, haben Sie sich verzweigt, je nachdem, ob Sie den Ursprung erreichen können.
- Wenn Sie den Ursprung nicht erreichen können, gehen Sie so nah wie möglich heran
- Wenn Sie es erreichen können, bewegen Sie es bis kurz vor Erreichen und bestimmen Sie, wie oft Sie es bewegen können.
- Wenn Sie den Ursprung gleichmäßig wiederholen, wird die Bewegung abgebrochen und ändert sich nicht vom ursprünglichen Ort.
- Im Falle einer ungeraden Anzahl von Malen ist dies aus dem oben genannten Grund der letzte Zug.
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)
D Problem
(Die Antwort ist nicht korrekt. Es gibt einen Testfall, der zu RE wird, daher werden wir den Fehler beheben, sobald der Testfall veröffentlicht wird.) Ich denke, die Punkte waren wie folgt.
--Loop Erkennung
- Verzweigen Sie, wenn der Wert für jede Schleife steigt und wenn er sinkt
- Wenn es für jede Schleife ausfällt, ist es ein Verlust, wenn Sie die Schleife wiederholen. Suchen Sie also den Maximalwert in der ersten Schleife
- Wenn Sie für jede Schleife nach oben gehen möchten, addieren Sie die Punktzahl der Schleife bis zu eins vor der letzten Schleife und den Maximalwert im Abschnitt eins vor der letzten Schleife + der letzten Schleife.
- Der Grund für das Einfügen der vorherigen Schleife in den Abschnitt zur Suche nach Maximalwerten ist, dass, wenn Sie eine Schleife mit einer Punktzahl wie -1-> -2-> 100 durchführen und die letzte Schleife aufgrund von K -2 endet, die letzte Dies liegt daran, dass es besser ist, mit 100 zu beenden, was eins vor der Schleife von ist.
- Der Eingabeindex beginnt bei 1, wurde jedoch zur Vereinfachung des Programms so geändert, dass er bei 0 beginnt.
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: #Wenn es jedes Mal nach unten geht, dreht es sich
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: #Wenn es jedes Mal hoch geht, dreht es sich
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)
Recommended Posts