Problemas de Codeforces | Isaac Lozano Osorio

1005A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,aux; cin>>n;
 vector<int> total;
 int res = 0;
 for(int i=0; i<n;i++)
 {
 cin>>aux;
 if(i!=0 && aux==1) {total.push_back(res); res=0;}
 res++;
 }
 total.push_back(res);
 cout<<total.size()<<'\n';
 for(unsigned int i=0; i<total.size();i++) if(i==0) cout<<total[i]; else cout<<" "<<total[i];
 return 0;
}

1005B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 string a,b; cin>>a; cin>>b;
 int flag=1,resu=a.length()+b.length();
 int al=a.length(); int bl=b.length();
 if (a==b) { flag=0; resu=0;}
 else if(al==bl) {
 for(int i=al; i>=0;i--) {
 if(a[i]!=b[i]) { if(flag==1) resu=(i+1)*2; break;} else flag=1;
 }
 }
 else
 {
 int aux=0,aa=al,bb=bl; aa--; bb--;
 for(int i=min(aa,bb); i>=0;i--){
 if(a[aa]!=b[bb]) break; else flag=1; aux++; aa--; bb--;
 }
 if(flag==1)
 {
 resu=(min(al,bl)-aux)*2;
 if(al>bl) resu+=(al-bl);
 else resu+=(bl-al);
 }
 }
 cout<<resu<<'\n';
 return 0;
}

1005C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 long long int nu; cin>>nu; int resu=0;
 int num[nu];
 map<long long int,int> M;
 for(int i=0; i<nu;i++) { cin>>num[i]; M[num[i]]++; }
 for (int i = 0; i < nu; i++)
 {
 int flag=0;
 for (int k = 0; k < 32 && flag==0; k++) {
 int x = (1 << k) - num[i];
 if(M.count(x) && (M[x] > 1 || (M[x] == 1 && x != num[i]))) flag=1;
 }
 if(flag==0) resu++;
 }
 cout<<resu<<'\n';
 return 0;
}

1005D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1005D

#include <bits/stdc++.h>
using namespace std;

int main()
{
 string s;
 cin >> s;
 int n = s.length(), ans = 0;
 string t, z, q;
 for(int i=0; i<n; i++){
 t += s[i];
 z = s[i];
 q = t;
 q.erase(0, 1);
 long long x = stoll(t);
 long long y = stoll(z);
 long long xx;
 if(!q.empty()) xx = stoll(q);
 else xx = 1;
 if(x % 3 == 0 || y%3==0 || xx % 3 == 0){ ans++; t.clear();}
 else if(t.length() >= 18) t.erase(0,1);
 }
 cout << ans;
 return 0;
}

101482C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101482C

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int round(int num)
{
 if (num%10<5)return num-(num%10);
 return num+(10-(num%10));
}
int main()
{
 int n,d,aux,total=0;
 scanf("%d%d",&n,&d);
 int memo[n][d+1];
 int arracu[n];
 for(int i=0; i<n;i++) { scanf("%d",&aux); total+=aux; arracu[i]=total;}
 for(int i = 0; i<=d;i++)
 for(int j=0; j<n;j++)
 {
 if(i==0) memo[j][i]=round(arracu[j]);
 else
 {
 int mini = round(arracu[j]);
 for(int k=0; k<j;k++)
 {
 aux = round(memo[k][i-1]+round(arracu[j]-arracu[k]));
 mini=min(mini,aux);
 }
 memo[j][i]=mini;
 }
 }
 printf("%d\n",round(memo[n-1][d]));
 return 0;
}

101482H — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101482H

import java.util.*;
import java.util.stream.Collectors;

public class Main {

 private static Scanner sc = new Scanner(System.in);
 private static Set<Integer> visitados = new HashSet<>();
 private static int next = 1;

 public static void main(String[] args) {
 int n = sc.nextInt();

 Node[] nodes = new Node[n+1];

 for (int i = 1; i < nodes.length; i++) {
 nodes[i] = new Node();
 }

 while(sc.hasNextInt()){
 int parent = sc.nextInt();
 int child = sc.nextInt();

 nodes[parent].children.add(child);
 nodes[child].children.add(parent);
 }

 assignFreq(nodes, 1, next++, next++);

 for (int i = 1; i < nodes.length; i++) {
// if(nodes[i].freqA == -1 || nodes[i].freqB == -1){
// while (true);
// }
 System.out.println(nodes[i].freqA + " " + nodes[i].freqB);
 }
 }

 /**
 *
 * @param nodes
 * @param mFreq mandatory frecuency
 * @param vFreq voluntary frecuency
 */
 public static void assignFreq(Node[] nodes, int i, int mFreq, int vFreq){

 visitados.add(i);

 Node n = nodes[i];
 n.freqA = mFreq;
 List<Integer> children = n.children.stream().filter(e -> !visitados.contains(e)).collect(Collectors.toList());
 if(children.isEmpty()){
 n.freqB = vFreq;
 } else {
 n.freqB = next++;
 for (int i1 = 0; i1 < (children.size() + 1)/2; i1++) {
 int child = children.get(i1);
 assignFreq(nodes, child, n.freqB, n.freqA);
 }
 for (int i1 = (children.size() + 1)/2; i1 < children.size(); i1++) {
 int child = children.get(i1);
 assignFreq(nodes, child, n.freqA, n.freqB);
 }
 }
 }

 public static class Node {
 ArrayList<Integer> children = new ArrayList<>();
 int freqA = -1;
 int freqB = -1;
 }
}

101482J — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101482J

#include <bits/stdc++.h>
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int n; scanf("%d",&n);
 map<string,int> M;
 map<string,int> Maux;
 for(int i=0; i<n;i++)
 {
 string line; cin>>line;
 M[line]++;
 }
 for(int i=0; i<n;i++)
 {
 string line; cin>>line;
 Maux[line]++;
 }
 long long int res = 0;
 for(auto m:M)
 {
 if(Maux[m.first]==0) continue;
 else res+=min(Maux[m.first],m.second);
 }
 printf("%lld\n",res);
 return 0;
}

101620_CERC2017A_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101620_CERC2017A_CODEFORCES

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int r,p; scanf("%d%d",&r,&p);
 int peopleleft=0, peopleright=0;
 char matrix[r+3][11];
 int numasientos[r+3][11]; memset(numasientos,0,sizeof(numasientos));
 int arr[r+3]; memset(arr,0,sizeof(arr));
 char a;
 for(int i=0; i<r+3;i++)
 {
 for(int j=0; j<11;j++)
 {
 cin>>a; matrix[i][j]=a;
 if(a=='#' && j<5) peopleleft++;
 else if(a=='#' && j>5) peopleright++;
 if(a=='#') { arr[i]++; numasientos[i][j]++;}
 }
 }
 char letra = 'a';
 for(int i=0; i<p;i++)
 {
 //solve A and B rule
 int mini = INF,row=-1;
 /*
 ........... 0
 ---.---.--- 1
 ........... 2
 ---.---.--- 3
 ........... 4

 2 + 3 = 5/2 = 2
 */
 int middlexit = (r+3)/2;
 if(arr[1]!=9 || arr[middlexit+1]!=9)
 {
 //filas no completas cerca de salidas
 if(arr[middlexit+1]<arr[1]) row=middlexit+1;
 else row=1;
 }
 else
 {
 int flag=0;
 vector<int> V;
 for(int k=0; k<r+3;k++)
 {
 if(k==0 || k==r+2 || k==middlexit) continue;
 if(mini>arr[k]) { mini=arr[k]; row=k; flag=0; V.clear();}
 else if(mini==arr[k]) { if(flag==0) V.push_back(row); flag=1; V.push_back(k); }
 }
 if(flag==1)
 {
 flag=0;
 vector<int> aux;
 mini = INF;
 for(unsigned int k1=0; k1<V.size();k1++)
 {
 //r = 2 -> r = 5 -> 0 2 4
 int minaux = min(abs(V[k1]-0),min(abs(V[k1]-(middlexit)),abs(V[k1]-(r+2))));
 if(mini>minaux) { mini=minaux; row=V[k1]; flag=0; aux.clear();}
 else if(mini==minaux) {
 if(flag==0) aux.push_back(row); flag = 1; aux.push_back(V[k1]);
 }
 }
 if(flag==1)
 {
 sort(aux.begin(),aux.end());
 row = aux[0];
 }
 }
 }
 // ---.---.---
 // 012345678910
 //Seleccionar asiento
 if(numasientos[row][4]==0 || numasientos[row][6]==0)
 {
 if(numasientos[row][4]==0 && numasientos[row][6]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][4]++;
 matrix[row][4]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][6]++;
 matrix[row][6]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][4]==0)
 {
 peopleleft++;
 numasientos[row][4]++;
 matrix[row][4]= letra;
 }
 else{
 peopleright++;
 numasientos[row][6]++;
 matrix[row][6]= letra;
 }
 }
 else if(numasientos[row][2]==0 || numasientos[row][8]==0)
 {
 if(numasientos[row][2]==0 && numasientos[row][8]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][2]++;
 matrix[row][2]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][8]++;
 matrix[row][8]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][2]==0)
 {
 peopleleft++;
 numasientos[row][2]++;
 matrix[row][2]= letra;
 }
 else{
 peopleright++;
 numasientos[row][8]++;
 matrix[row][8]= letra;
 }

 }
 else if(numasientos[row][0]==0 || numasientos[row][10]==0)
 {
 if(numasientos[row][0]==0 && numasientos[row][10]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][0]++;
 matrix[row][0]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][10]++;
 matrix[row][10]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][0]==0)
 {
 numasientos[row][0]++;
 matrix[row][0]= letra;
 peopleleft++;
 }
 else{
 numasientos[row][10]++;
 matrix[row][10]= letra;
 peopleright++;
 }
 }
 else if(numasientos[row][5]==0)
 {
 numasientos[row][5]++;
 matrix[row][5] = letra;
 }
 else{
 if(numasientos[row][1]==0 && numasientos[row][9]==0)
 {
 if(peopleleft<=peopleright)
 {
 numasientos[row][1]++;
 matrix[row][1]= letra;
 peopleleft++;
 }
 else{
 peopleright++;
 numasientos[row][9]++;
 matrix[row][9]= letra;
 }
 }
 else if(numasientos[row][1]==0)
 {
 peopleleft++;
 numasientos[row][1]++;
 matrix[row][1]= letra;
 }
 else{
 peopleright++;
 numasientos[row][9]++;
 matrix[row][9]= letra;
 }
 }
 arr[row]++;
 letra++;
 }
 //imprimir
 for(int i=0; i<r+3;i++)
 {
 for(int j=0; j<11;j++)
 cout<<matrix[i][j];
 cout<<'\n';
 }
 return 0;
}

101620_CERC2017H_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101620_CERC2017H_CODEFORCES

import java.util.*;

public class Main {

 public static final StringBuilder sb = new StringBuilder(10000);

 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 Node root = new Node(0);
 int lines = sc.nextInt();
 sc.nextLine();
 for (int i = 0; i < lines; i++) {
 String line = sc.nextLine();
 String[] temp = line.split(" ");
 int fileSize = Integer.parseInt(temp[1]);
 String[] folders = temp[0].split("/");
 root.add(folders, 1, fileSize);
 }
 int limit = sc.nextInt();
 root.calculateSize();
 root.recursivePrint("", limit);
 System.out.print(sb.toString());
 }

 static class Node {
 long size;
 long accumulatedSize = -1;
 boolean hasFolder = false;

 public Node(long size) {
 this.size = size;
 }

 Map<String, Node> children = new HashMap<>();

 public void add(String[] array, int position, int size){
 if(array.length - 1 == position){
 this.children.put(array[position], new Node(size));
 } else {
 if(!this.children.containsKey(array[position])){
 this.children.put(array[position], new Node(0));
 }
 this.hasFolder = true;
 this.children.get(array[position]).add(array, position+1, size);
 }
 }

 public long calculateSize(){
 if(this.accumulatedSize == -1){
 this.accumulatedSize = this.children.size() == 0 ? this.size: this.children.entrySet().stream().map(Map.Entry::getValue).mapToLong(Node::calculateSize).reduce(0, (a,b) -> a+b);
 }
 return this.accumulatedSize;
 }

 public void recursivePrint(String path, int limit){
 if(this.children.size() == 0) return;
 boolean expandIt = hasFolder && this.children.entrySet().stream().map(Map.Entry::getValue).anyMatch(e -> !e.children.isEmpty() && e.accumulatedSize >= limit);
 if(expandIt){
 sb.append("- ");
 }
 else if(hasFolder) {
 sb.append("+ ");
 }
 else {
 sb.append(" ");
 }
 sb.append(path).append('/').append(' ').append(accumulatedSize).append('\n');

 if(expandIt){
 this.children.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getKey)).forEach((e) -> e.getValue().recursivePrint(path + '/' + e.getKey(), limit));
 }
 }
 }
}

101635A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635A

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases;
 while(scanf("%d",&cases)!=EOF)
 {
 int m; cin>>m;
 map<long long int, long long int> a;
 long long int arr1[cases]; long long int arr2[m];
 for(int i=0; i<cases;i++) cin>>arr1[i];
 for(int i=0; i<m;i++) cin>>arr2[i];

 for(int i=0; i<cases;i++)
 for(int j=0; j<m;j++)
 {
 long long int res = arr2[j]-arr1[i];
 if(res<=0) continue;
 if(a.insert(pair<long long int,long long int>(res,1)).second == false)
 {
 long long int k = a.find(res)->second;
 k++;
 map<long long int,long long int>::iterator it = a.find(res);
 if (it != a.end())
 it->second = k;
 }
 }
 map<long long int,long long int>::iterator it = a.begin();
 long long int sol=0, resul=0;
 for (it=a.begin(); it!=a.end(); ++it)
 {
 if(it->second>sol){ resul=it->first; sol=it->second;}
 // cout << it->first <<" "<< it->second << '\n';
 }
 cout<<resul<<endl;
 }
 return 0;
}

101635F — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635F

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int cases;
 while(scanf("%d",&cases)!=EOF)
 {
 long long int num,a,b,res=0; cin>>num;
 for(int i=0; i<num;i++)
 {
 cin>>a>>b;
 res+=(a*b);
 }
 cout<<res/cases<<endl;
 }
 return 0;
}

101635J — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635J

#include <bits/stdc++.h>
using namespace std;
int main(){
long long int y,p,w; int cases;
 while(scanf("%d",&cases)!=EOF)
 {
 y=0; p=0; w=0;
 int arr1[cases]; int arr2[cases];
 for(int i=0; i<cases;i++) cin>>arr1[i];
 for(int i=0; i<cases;i++) cin>>arr2[i];

 long long int aw=0,ay=0,ap=0,aw1=0,ay1=0,ap1=0,aw2=0,ay2=0,ap2=0,aw3=0,ay3=0,ap3=0;

 for(int i=0; i<cases;i++)
 {
 if(i<3)
 {
 for(int j=0; j<cases;j++)
 {
 if(i==0){ aw+=arr1[j]; if(j+1>=cases) break; j++; ay+=arr1[j]; if(j+1>=cases) break; j++; ap+=arr1[j]; }
 else if(i==1){ ay+=arr1[j]; if(j+1>=cases) break; j++; ap+=arr1[j]; if(j+1>=cases) break; j++; aw+=arr1[j]; }
 else{ ap+=arr1[j]; if(j+1>=cases) break; j++; aw+=arr1[j]; if(j+1>=cases) break; j++; ay+=arr1[j]; }
 }
 if(i==0){ ap1=ap; aw1=aw; ay1=ay; }
 else if(i==1){ ap2=ap; aw2=aw; ay2=ay; }
 else{ ap3=ap; aw3=aw; ay3=ay; }
 y+=arr2[i]*ay; p+=arr2[i]*ap; w+=arr2[i]*aw; ap=0; aw=0; ay=0;
 }
 else
 {
 if(i%3==0){ y+=arr2[i]*ay1; p+=arr2[i]*ap1; w+=arr2[i]*aw1; }
 else if(i%3==1){ y+=arr2[i]*ay2; p+=arr2[i]*ap2; w+=arr2[i]*aw2; }
 else{ y+=arr2[i]*ay3; p+=arr2[i]*ap3; w+=arr2[i]*aw3; }
 }
 }
 cout<<y<<" "<<p<<" "<<w<<endl;
 }
 return 0;
}

101635K — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101635K

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <algorithm>
using namespace std;
#define eps 1e-8
struct Pt {
 double x, y;
 Pt(double a = 0, double b = 0):
 x(a), y(b) {}
 bool operator<(const Pt &a) const {
 if(fabs(x-a.x) > eps) return x < a.x;
 return y < a.y;
 }
 bool operator==(const Pt &a) const {
 return fabs(x-a.x) < eps && fabs(y-a.y) < eps;
 }
 Pt operator+(const Pt &a) const {
 return Pt(x + a.x, y + a.y);
 }
 Pt operator-(const Pt &a) const {
 return Pt(x - a.x, y - a.y);
 }
 Pt operator/(const double val) const {
 return Pt(x / val, y / val);
 }
 Pt operator*(const double val) const {
 return Pt(x * val, y * val);
 }
};
typedef Pt Vector;
double dist(Pt a, Pt b) {
 return hypot(a.x - b.x, a.y - b.y);
}
double dot(Pt a, Pt b) {
 return a.x * b.x + a.y * b.y;
}
double cross2(Pt a, Pt b) {
 return a.x * b.y - a.y * b.x;
}
double cross(Pt o, Pt a, Pt b) {
 return (a.x-o.x)*(b.y-o.y)-(a.y-o.y)*(b.x-o.x);
}
int between(Pt a, Pt b, Pt c) {
 return dot(c - a, b - a) >= 0 && dot(c - b, a - b) >= 0;
}
int onSeg(Pt a, Pt b, Pt c) {
 return between(a, b, c) && fabs(cross(a, b, c)) < eps;
}
int cmpZero(double x) {
 if (fabs(x) < eps) return 0;
 return x > 0 ? 1: -1;
}
double ptToLine(Pt p, Pt s, Pt e) {
 double area = fabs(cross(p, s, e));
 double h = area / dist(s, e);
 return h;
}
int monotone(int n, Pt p[], Pt ch[]) {
 sort(p, p+n);
 int m = 0;
 for (int i = 0; i < n; i++) {
 while (m >= 2 && cross(ch[m-2], ch[m-1], p[i]) <= 0)
 m--;
 ch[m++] = p[i];
 }
 for (int i = n-1, t = m+1; i >= 0; i--) {
 while (m >= t && cross(ch[m-2], ch[m-1], p[i]) <= 0)
 m--;
 ch[m++] = p[i];
 }
 return m-1;
}
double convex_width(Pt pt[], int n) {
 if (n <= 2)
 return 0;
 double ret = 1e+60;
 pt[n] = pt[0];
 // rotating caliper
 for (int i = 0, j = 0; i < n; i++) {
 while (cross(pt[i], pt[i+1], pt[j+1]) >= cross(pt[i], pt[i+1], pt[j]))
 j = (j+1)%n;
 double dist = ptToLine(pt[j], pt[i], pt[i+1]);
 ret = min(ret, dist);
 }
 return ret;
}
int main() {
 static const int MAXN = 262144;
 static Pt pt[MAXN], ch[MAXN];
 int n, m;
 int64_t r;
 while (scanf("%d %lld", &n, &r) == 2) {
 for (int i = 0; i < n; i++) {
 int x, y;
 scanf("%d %d", &x, &y);
 pt[i] = Pt(x, y);
 }
 m = monotone(n, pt, ch);
 double mn_width = convex_width(ch, m);
 printf("%.17lf\n", mn_width);
 }
 return 0;
}

101889_COMPLETENARBBIRACS_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101889_COMPLETENARBBIRACS_CODEFORCES

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int k,n; scanf("%d%d",&k,&n);
 int arr[k]; memset(arr,0,sizeof(arr));
 int maxi=0,mini=INF,medio=0;
 int num1,num2,flag; num1=num2=flag=-1;
 for(int i=0; i<n;i++)
 {
 int x; scanf("%d",&x);
 arr[x-1]++;
 }
 for(int i=0; i<k;i++) {
 if(maxi<arr[i]) {maxi=arr[i]; num1=i+1;}
 if(mini>arr[i]) {mini=arr[i]; num2=i+1;}
 }
 if(n%k == 0) medio = n/k;
 else if(n%k==1) medio = n/k;
 else if(n%k==k-1) medio = (n+1)/k;
 else medio = INF;

 if(maxi==medio) flag=1;
 else if(mini==medio) flag=0;
 else if((maxi-1)==medio && (mini+1) == medio) flag=2;

 if(flag==-1) printf("*\n");
 else if(flag==0)printf("-%d\n",num1);
 else if(flag==1) printf("+%d\n",num2);
 else printf("-%d +%d\n",num1,num2);
 return 0;
}

101889_HARDCHOICE_CODEFORCES — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101889_HARDCHOICE_CODEFORCES

#include <bits/stdc++.h>
using namespace std;

int main()
{
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 int n1,n2,n3,m1,m2,m3;
 scanf("%d%d%d",&n1,&n2,&n3);
 scanf("%d%d%d",&m1,&m2,&m3);
 int ac = 0;
 if((m1-n1)>0) ac+=(m1-n1);
 if((m2-n2)>0) ac+=(m2-n2);
 if((m3-n3)>0) ac+=(m3-n3);
 printf("%d\n",ac);
 return 0;
}

101954A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101954A

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class die {

 public static void main(String[] args) throws IOException {
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 StringBuilder sb = new StringBuilder(1000);
 String[] lines = new String[3];
 lines[0] = br.readLine();
 lines[1] = br.readLine();
 lines[2] = br.readLine();
 if (checkpos(lines, ":::", ":o:", ":::")){
 sb.append(1);
 }
 else if (checkpos(lines, "o::", ":::", "::o")){
 sb.append(2);
 }
 else if (checkpos(lines, "::o", ":::", "o::")){
 sb.append(2);
 }
 else if (checkpos(lines, "o::", ":o:", "::o")){
 sb.append(3);
 }
 else if (checkpos(lines, "::o", ":o:", "o::")){
 sb.append(3);
 }
 else if(checkpos(lines, "o:o", ":::", "o:o")){
 sb.append(4);
 }
 else if (checkpos(lines, "o:o", ":o:", "o:o")){
 sb.append(5);
 }
 else if (checkpos(lines,"ooo",":::","ooo")){
 sb.append(6);
 }
 else if (checkpos(lines,"o:o","o:o","o:o")){
 sb.append(6);
 } else {
 sb.append("unknown");
 }
 System.out.println(sb.toString());
 }

 public static boolean checkpos(String[] lines, String l1, String l2, String l3){
 boolean ret = true;
 ret = ret && lines[0].equals(l1);
 ret = ret && lines[1].equals(l2);
 ret = ret && lines[2].equals(l3);
 return ret;
 }

}

101954B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 101954B

#include <iostream>
#include <queue>
#include <string.h>
#define INF 0x3f3f3f3f
#define fi first
#define se second
using namespace std;

int res[5005][5005];
bool flag[5005][5005];
int sx[]={1,-1,0,0,1,-1,-1,1}; //8 directions
int sy[]={0,0,1,-1,1,-1,1,-1};
int c,r;
queue<pair<int,int> > f;

void BFS()
{
 while(!f.empty()){
 auto x=f.front();
 f.pop();
 for(int i=0;i<8;i++){
 auto y=x;
 y.fi+=sx[i];
 y.se+=sy[i];
 if(y.fi>=0&&y.fi<=c&&y.se>=0&&y.se<=r && !flag[y.fi][y.se]){
 flag[y.fi][y.se]=true;
 res[y.fi][y.se]=res[x.fi][x.se]+1;
 f.push(y);
 }
 }
 }
}

int main()
{
 int n,m,x,y; scanf("%d%d",&n,&m);
 memset(res,0,sizeof(res));
 memset(flag,false,sizeof(flag));
 c=r=5000;
 for(int i=0; i<n;i++)
 {
 scanf("%d%d",&x,&y);
 if(flag[x][y]==false) f.push({x,y});
 flag[x][y]=true;
 }
 BFS();
 for(int i=0; i<m;i++)
 {
 scanf("%d%d",&x,&y);
 printf("%d\n",res[x][y]);
 }
 return 0;
}

102465A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102465A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,on,off,res=0,k,num;
 scanf("%d",&n); on=n; off=0;
 bool arr[n+1];
 memset(arr,true,sizeof(arr));
 scanf("%d",&k);
 while(k--)
 {
 scanf("%d",&num);
 for(int i=num; i<=n; i+=num)
 {
 if(arr[i-1]) { off++; on--; arr[i-1]=false;}
 else {off--; on++; arr[i-1]=true;}
 }
 res = max(off,res);
 }
 printf("%d\n",res);
 return 0;
}

102501B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501B


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 map<string,int> M;
 int total=0;
 while(cases--){
 string s; cin>>s;
 M[s]++;
 total++;
 }
 int flag=0;
 for(auto m:M){
 if(m.second>(total-m.second)) { cout<<m.first<<endl; flag=1; break;}
 }
 if(flag==0) printf("NONE\n");
 return 0;
}

102501C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501C


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 set<int> S;
 for(int i=0; i<cases;i++){
 string num; cin>>num;
 if(num[0]=='-' || num.length()>8) continue;
 S.insert(stoi(num));
 }
 set<int>::iterator it = S.begin();
 int flag = 0,last=0;
 while (it != S.end())
 {
 if(*it==last) { it++; last++; continue; }
 else { flag=2; printf("%d\n",last); break;}
 it++;
 }
 if(flag==0) printf("%d\n",last);
 return 0;
}

102501F — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501F


#include <bits/stdc++.h>
using namespace std;
#define EPS 1e-9
#define PI acos(-1.0)
typedef long long int ll;
struct point{
 double x,y;
 point(){x=y=0;}
 point(int _x,int _y){x=_x,y=_y;}
 bool operator <(point other) const{
 if (fabs(x-other.x)>EPS)return x<other.x;
 return y<other.y;
 }bool operator ==(point other) const{
 return (fabs(x-other.x)<EPS)&&
 (fabs(y-other.y)<EPS);
 }
 point operator +(point other) const{
 return point(x+other.x,y+other.y);
 }point operator -(point other) const{
 return point(x-other.x,y-other.y);
 }
};

double calc_area(vector<point> Pa) {
 double ans = 0;
 for (int i = 0; i < (int) Pa.size() - 1; i++)
 ans += Pa[i].x * Pa[i + 1].y - Pa[i].y * Pa[i + 1].x;
 return fabs(ans) / 2.0;
}

int main(){
 int cases; scanf("%d",&cases);
 double area = 0;
 while(cases--){
 int points; scanf("%d",&points);
 vector<point> V;
 for(int i=0; i<points;i++){
 int x,y; scanf("%d %d",&x,&y);
 V.push_back(point{x,y});
 }
 V.push_back(V[0]);
 area+=calc_area(V);
 }
 printf("%lld\n",(long long int)area);
}

102501I — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501I


#include <bits/stdc++.h>
using namespace std;

int main(){
 int n1,n2,n3; scanf("%d %d %d",&n1,&n2,&n3);
 printf("%d\n",((n1+1)*(n2+1))/(n3+1)-1);
 return 0;
}

102501K — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 102501K

#include <bits/stdc++.h>
using namespace std;

int N,E;
const int MAXN = 100100;
struct edge{
 int from, to;
 edge(){}
 edge(int a, int b){
 from = a;
 to = b;
 }
};

vector<edge> graph[MAXN];
vector<edge> rgraph[MAXN];

int main(){
 int CHECK;
 scanf("%d %d %d",&N,&E,&CHECK);
 bool visited[N+2],visited2[N+2];
 int visited1[N+2];
 memset(visited,false,sizeof(visited));
 set<int> C,S;
 for(int i=0;i<E;i++){
 int from, to; scanf("%d %d",&from, &to);
 if(to==CHECK && from!=CHECK) { C.insert(from); S.insert(from); visited[from]=true;} //nodes with direct path and diffent to check
 else if(to!=CHECK && from!=CHECK) { graph[from].push_back(edge(from,to)); rgraph[to].push_back(edge(to,from));}//delete edge
 }
 map<int,bool> M;
 memset(visited1,-1,sizeof(visited1));
 for(int i:C){
 if(M[i]) continue;
 memset(visited2,false,sizeof(visited2));
 queue<int> q; q.push(i);
 bool flag = true;
 while(!q.empty() && flag){
 int ele = q.front();
 q.pop();
 for(unsigned int j=0;j<graph[ele].size();j++){
 if(visited[graph[ele][j].to] && graph[ele][j].to!=i) {
 S.erase(i);
 M[i]=true;
 if(visited1[graph[ele][j].from]==-1){
 queue<int> test;
 test.push(graph[ele][j].from); visited1[i]=i;
 while(!test.empty()){
 int aux = test.front();
 test.pop();
 for(unsigned int l=0;l<rgraph[aux].size();l++){
 if(rgraph[aux][l].to!=i && visited1[rgraph[aux][l].to]==-1 && visited2[rgraph[aux][l].to]) test.push(rgraph[aux][l].to);
 if(visited2[rgraph[aux][l].to]) {
 visited1[rgraph[aux][l].to]=graph[ele][j].to;
 }
 }
 }
 }
 flag=false;
 break;
 }
 if(visited1[graph[ele][j].to]!=-1 && visited1[graph[ele][j].to]!=i){
 //cout<<"PODA\n";
 S.erase(i);
 M[i]=true;
 flag=false;
 break;
 }
 if(!visited2[graph[ele][j].to]) q.push(graph[ele][j].to);
 visited2[graph[ele][j].to]=true;
 }
 }
 }
 printf("%d\n",S.size());
 for(auto s:S){
 printf("%d\n",s);
 }
 return 0;
}

/*
5 7 0
1 0
2 1
1 3
3 2
2 0
3 4
4 0
*/

/*
5 6 0
2 0
1 0
1 6
3 6
6 2
2 3
*/

1029A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1029A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n,k,aux;
 string res,resu;
 cin>>n>>k>>res; aux=n-1;
 while(res.substr(0,aux)!=res.substr(n-aux)) aux--;
 for(unsigned int i=aux; i<res.length();i++) resu+=res[i];
 for(int i=0; i<k-1;i++) res+=resu;
 cout<<res<<'\n';
 return 0;
}

1029B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1029B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int n; cin>>n;
 int arr[n];
 for(int i=0; i<n;i++) cin>>arr[i];
 int res=1,sum=1,aux=0;
 for (int i=0;i<n;i++)
 {
 for(int j=i+1; j<n;j++)
 {
 sum++;
 if(arr[j-1]*2>=arr[j]) { res= max(res,sum); aux=j;}
 else
 {
 i=j-1; sum=1; break;
 }
 }
 if(aux==n-1) break;
 }
 cout<<res<<'\n';
 return 0;
}

103577H — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 103577H


#include<bits/stdc++.h>
#define mid ((l+r)/2)
using namespace std;
typedef double db;
db d;
db gett(db x1,db v1,db x2,db v2)
{
 db l=0,r=fabs((x1-x2)/(v1-v2));
 for(int i=1;i<=100;i++)
 {
 if(v2<0)
 {
 if(x2+v2*mid-min(d,x1+v1*mid)>1e-10)l=mid;
 else r=mid;
 }
 else
 {
 if(x2+v2*mid-min(d,x1+v1*mid)>1e-10)r=mid;
 else l=mid;
 }
 }
 return mid;
}
int main()
{
 db v0,v1,v2,t;
 db x0=0,x1=1,x2=0;
 cin>>d>>v0>>v1>>v2>>t;
 while(1)
 {
 db r=gett(x1,v1,x2,v2);
 if(r-t>1e-8||fabs(r-t)<=1e-8){printf("%.12f\n",x2+v2*t);return 0;}
 x2=x2+v2*r;
 x0=min(d,x0+v0*r);
 x1=min(d,x1+v1*r);
 t-=r;

 r=gett(x0,v0,x2,-v2);
 if(r-t>1e-8||fabs(r-t)<=1e-8){printf("%.12f\n",x2-v2*t);return 0;}
 x2=x2-v2*r;
 x0=min(d,x0+v0*r);
 x1=min(d,x1+v1*r);
 t-=r;
 if(fabs(x0-d)<1e-8)break;
 }
 printf("%.12f\n",x2);
 return 0;
}

1055A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1055A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,s; scanf("%d%d",&n,&s); s--;
 bool res[n];
 for(int i=0; i<n;i++)
 {
 int num; scanf("%d",&num);
 if(num==1) res[i]=true;
 else res[i]=false;
 }
 bool res1[n];
 for(int i=0; i<n;i++)
 {
 int num; scanf("%d",&num);
 if(num==1) res1[i]=true;
 else res1[i]=false;
 }
 bool resn=false;
 for(int i=n-1; i>=s && !resn;i--)
 {
 if(res[i] && res1[i] && res1[s]) resn=true;
 }
 if((resn && res[0]) || (res[0] && res[s])) printf("YES\n");
 else printf("NO\n");
 return 0;
}

1055B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1055B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 long long int n,m,l,q,p,d,res=0; scanf("%lld%lld%lld",&n,&m,&l);
 long long int arr[n];
 for(int i=0; i<n;i++) scanf("%lld",&arr[i]);
 bool first=false;
 int memo[n]; memset(memo,0,sizeof(memo));
 for(int i=0; i<n;i++)
 {
 if(arr[i]>l && first) res--;
 else first=false;
 if(arr[i]>l) { first=true; res++; memo[i]=1; }
 }
 while(m--)
 {
 scanf("%lld",&q);
 if(q==0){
 printf("%lld\n",res);
 }
 else{
 scanf("%lld%lld",&p,&d);
 arr[p-1]+=d;
 if(arr[p-1]>l && memo[p-1]!=1)
 {
 memo[p-1]=1; res++;
 if(p!=n) { res-=memo[p]; }
 if(p!=1) { res-=memo[p-2];}
 }
 }
 }
 return 0;
}

1056A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1056A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; scanf("%d",&n);
 map<int,int> M;
 for(int i=0; i<n;i++)
 {
 int r; scanf("%d",&r);
 for(int j=0; j<r;j++)
 {
 int aux; scanf("%d",&aux);
 M[aux]++;
 }
 }
 int flag=1;
 for(auto m:M)
 {
 if(m.second == n)
 {
 if(flag==1) { flag=2; printf("%d",m.first);}
 else printf(" %d",m.first);
 }
 }
 return 0;
}

1056B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1056B

//B
#include <bits/stdc++.h>
using namespace std;
int main()
{
 int n,m; scanf("%d%d",&n,&m);
 long long int res = 0;
 if(m==1) { res=n; printf("%lld",res*res); }
 else if(m>n) {
 for(int i=1; i<=n;i++)
 for(int j=1; j<=i;j++)
 if((i*i+j*j) % m ==0)
 {
 if(i==j) res++; else res+=2;
 }
 printf("%lld",res);
 }
 else{
 for(int i=1; i<=m;i++)
 for(int j=1; j<=i;j++)
 if((i*i+j*j) % m ==0)
 {
 if(i==j) res++; else res+=2;
 }

 //sobrante
 long long int p =0;
 for(int i=1; i<=n%m;i++)
 for(int j=1; j<=m;j++)
 if((i*i+j*j) % m ==0) p++;

 int aux = n/m;
 res=res*aux*aux; res+=p*(n/m)*2;
 p=0;
 for(int i=1; i<=n%m;i++)
 for(int j=1; j<=n%m;j++)
 if((i*i+j*j) % m ==0) p++;
 res+=p;
 printf("%lld",res);
 }
 return 0;
}

1061A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1061A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n,S; scanf("%d%d",&n,&S);
 if(S%n==0) printf("%d",S/n);
 else printf("%d",S/n+1);
 return 0;
}

1061B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1061B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 long long int n,s, c=0;
 scanf("%lld%lld",&n,&s);
 int arr[n]; s=0;
 for(int i=0;i<n;i++) {scanf("%d",&arr[i]); s+=arr[i]; }
 sort(arr,arr+n);
 for(int i=0;i<n;i++)c+=arr[i]>c;
 printf("%lld",s-n-arr[n-1]+c); //total blocks - number of blocks top - number of block rigth + blocks
 return 0;
}

1064A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1064A

#include <bits/stdc++.h>

using namespace std;

int main() {
 int A,B,C;
 while(scanf("%d%d%d",&A,&B,&C)==3)
 {
 int res = 0;
 if(A>=B && A>=C)
 {
 if(!(A<(B+C))) res=A-B-C+1;
 }
 if(B>=A && B>=C)
 {
 if(!(B<(A+C))) res=B-A-C+1;
 }
 if(C>=B && C>=A)
 {
 if(!(C<(B+A))) res=C-B-A+1;
 }
 cout<<res<<'\n';
 }
 return 0;
}

1064B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1064B

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int main() {
 int cases; scanf("%d",&cases);
 while(cases--)
 {
 long long int a; scanf("%lld",&a);
 string binary = bitset<32>(a).to_string(); //to binary
 long long int res = 0;
 for(unsigned int i=0; i<binary.length();i++) if(binary[i]=='1') res++;
 res = powl(2,res);
 cout<<res<<"\n";
 }
 return 0;
}

1064C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1064C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; cin>>n;
 string s; cin>>s;
 sort(s.begin(), s.end()); cout<<s<<'\n';
 /*
 int res = 0;
 char last = '\0';
 string au;
 for(int i=0;i<n;i++)
 {
 if(s[i]==last) res+=au.length();
 else au = "";
 res++;
 last=s[i];
 au += s[i];
 }
 printf("%d\n",res);*/
 return 0;
}

1066A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1066A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases,L,l,v,r; cin>>cases;
 while(cases--)
 {
 scanf("%d%d%d%d",&L,&v,&l,&r);
 int res = (l-1)/v;
 res+=(L-r)/v;
 int resto = (L-r)%v;
 int aux = 0;
 if(r%v!=0) {
 aux=((r/v)+1)*v;
 if(r+resto>=aux) res++;
 }
 printf("%d\n",res);
 }
 return 0;
}

1066C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1066C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int q;cin>>q;
 int l=1,r=0,i;
 int arr[200009];
 while(q--)
 {
 char c; cin>>c>>i;
 if(c=='L') {l--;arr[i]=l;}
 else if(c=='R') {r++;arr[i]=r;}
 else {printf("%d\n",min(arr[i]-l,r-arr[i]));}
 }
return 0;
}

1108A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);
 for(int i=0; i<cases;i++)
 {
 int n,n1,n2,n3; scanf("%d%d%d%d",&n,&n1,&n2,&n3);
 bool flag=true;
 for(int i=n; i<=n1 && flag; i++)
 for(int j=n2; j<=n2 && flag;j++)
 if(n<=i&&n1>=i && n2<=j && n3>=j && i!=j) { flag=false; printf("%d %d\n",i,j); }
 }
 return 0;
}

1108B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);
 int maxnum = -0x3f3f3f3f,nextnum=-0x3f3f3f3f;
 int arr[cases];
 map<int,int> M;
 map<int,int> Flag;
 for(int i=0; i<cases;i++)
 {
 scanf("%d",&arr[i]);
 maxnum=max(maxnum,arr[i]);
 M[arr[i]]++;
 }
 for(int i=0; i<cases;i++)
 {
 if(maxnum%arr[i]==0 && Flag[arr[i]]==0) { Flag[arr[i]]++; M[arr[i]]--; }
 }
 for(auto m:M)
 if(m.second!=0) nextnum=max(m.first,nextnum);
 printf("%d %d",maxnum,nextnum);
 return 0;
}

1108C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; scanf("%d",&n);
 string lamps; cin>>lamps;
 int count,count1;
 count=count1=0;
 string l,l1; l=l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //RGB
 {
 if(i%3==0 && lamps[i]!='R') { l[i]='R'; count++;}
 else if(i%3==1 && lamps[i]!='G'){ l[i]='G'; count++;}
 else if(i%3==2 && lamps[i]!='B') { l[i]='B'; count++;}
 }
 for(unsigned int i=0; i<lamps.size();i++) //RBG
 {
 if(i%3==0 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==2 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==1 && lamps[i]!='B'){ l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //GRB
 {
 if(i%3==1 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==0 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==2 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //GBR
 {
 if(i%3==2 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==0 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==1 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //BRG
 {
 if(i%3==1 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==2 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==0 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 count1=0; l1=lamps;
 for(unsigned int i=0; i<lamps.size();i++) //BGR
 {
 if(i%3==2 && lamps[i]!='R') { l1[i]='R'; count1++;}
 else if(i%3==1 && lamps[i]!='G'){ l1[i]='G'; count1++;}
 else if(i%3==0 && lamps[i]!='B') { l1[i]='B'; count1++;}
 }
 if(count1<count) { count=count1; l=l1;}
 printf("%d\n",count);
 cout<<l;
 return 0;
}

1108D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1108D

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; scanf("%d",&n);
 string lamps; cin>>lamps;
 int count=0;
 char c;
 for(unsigned int i=1; i<lamps.size();i++)
 {
 if(lamps[i-1]!=lamps[i]) continue;
 if(i+1<lamps.size())
 {
 c = lamps[i+1];
 if(c=='R' && lamps[i-1]=='B') lamps[i]='G';
 else if(c=='R' && lamps[i-1]=='G') lamps[i]='B';
 else if(c=='B' && lamps[i-1]=='G') lamps[i]='R';
 else if(c=='B' && lamps[i-1]=='R') lamps[i]='G';
 else if(c=='G' && lamps[i-1]=='B') lamps[i]='R';
 else if(c=='G' && lamps[i-1]=='R') lamps[i]='B';
 else if(c=='R' && lamps[i-1]=='R') lamps[i]='G';
 else if(c=='G' && lamps[i-1]=='G') lamps[i]='R';
 else if(c=='B' && lamps[i-1]=='B') lamps[i]='R';
 }
 else {
 c = lamps[i-1];
 if(c=='R') lamps[i]='G';
 else if(c=='B') lamps[i]='R';
 else if(c=='G') lamps[i]='R';
 }
 count++;
 }
 printf("%d\n",count);
 cout<<lamps;
 return 0;
}

1144A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; string a; scanf("%d",&cases);
 while(cases--)
 {
 bool flag = true,flag1=true;
 cin>>a;
 set<char> S;
 for(unsigned int i=0; i<a.length();i++) S.insert(a[i]);
 int ant = 0;
 for(auto s:S){

 if(flag1) { ant = s; flag1=false; continue;}
 if(ant+1!=s) { flag=false; break;}
 ant = s;
 }
 if(a.length()==S.size() && flag) printf("Yes\n");
 else printf("No\n");
 }
 return 0;
}

1144B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144B

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);int arr[cases];
 int par,impar; par=impar=0;
 for(int i=0;i<cases;i++) { scanf("%d",&arr[i]); if(arr[i]%2==0) par++; else impar++;}
 if(abs(par-impar)<2) printf("0\n");
 else {
 long long int sum = 0;
 sort(arr,arr+cases);
 if (par>impar) { for(int i=0; i<cases && abs(par-impar)>1;i++) if(arr[i]%2==0) { sum+=arr[i]; par--; } }
 else {
 for(int i=0; i<cases && abs(par-impar)>1;i++) if(arr[i]%2!=0) { sum+=arr[i]; impar--; }
 }
 printf("%lld\n",sum);
 }
 return 0;
}

1144C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144C

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int cases; scanf("%d",&cases);
 stack<int> S; int arr[cases];
 vector<int> R;
 for(int i=0;i<cases;i++) scanf("%d",&arr[i]);
 sort(arr,arr+cases);
 for(int i=0;i<cases;i++){
 if((R.size() != 0 && arr[i]==R[R.size()-1]) && (S.size()==0 || S.top()!=arr[i])) S.push(arr[i]);
 else if((R.size()==0 || arr[i]!=R[R.size()-1])) R.push_back(arr[i]);
 else break;
 }
 if(R.size()+S.size()!=cases) printf("NO\n");
 else {
 printf("YES\n%d\n",R.size());
 for(unsigned int i=0; i<R.size();i++) if(i==0) printf("%d",R[i]); else printf(" %d",R[i]);
 if(R.size()==0) printf("\n");
 printf("\n");
 printf("%d\n",S.size());
 int flag = 1;
 int aux = S.size();
 while(!S.empty()) { int e = S.top(); S.pop(); if(flag==1) {flag=0; printf("%d",e);} else printf(" %d",e); }
 if(aux==0) printf("\n");
 }
 return 0;
}

1144D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1144D

#include <bits/stdc++.h>
using namespace std;

bool visited[200500];
int cases;

bool check(int elem)
{
 return !((elem==0 && visited[elem+1]) || (elem == cases-1 && visited[cases-2]) || (elem != 0 && elem!=cases-1 && visited[elem+1] && visited[elem-1]));
}
int main()
{
 scanf("%d",&cases);
 int arr[cases];
 map<int,int> M;
 for(int i=0; i<cases;i++) { scanf("%d",&arr[i]); M[arr[i]]++; }
 int actual = 0,rep=0;
 for(auto m:M) if(m.second>actual) { actual=m.second; rep=m.first; }
 queue<int> index;
 memset(visited,false,sizeof(visited));
 for(int i=0; i<cases;i++) if(arr[i]==rep) { visited[i]=true; index.push(i);}
 printf("%d\n",cases-actual);
 int test = cases-actual;
 while(!index.empty() && test!=0)
 {
 int elem = index.front(); index.pop();
 if(elem-1>=0 && arr[elem-1]>rep && !visited[elem-1]) { printf("2 %d %d\n",elem,elem+1); visited[elem-1]=true; if(check(elem-1)) index.push(elem-1); test--; }
 if(elem+1<cases && arr[elem+1]>rep && !visited[elem+1]){ printf("2 %d %d\n",elem+2,elem+1); visited[elem+1]=true; if(check(elem+1)) index.push(elem+1); test--;}
 if(elem-1>=0 && arr[elem-1]<rep && !visited[elem-1]) { printf("1 %d %d\n",elem,elem+1); visited[elem-1]=true; if(check(elem-1)) index.push(elem-1); test--;}
 if (elem+1<cases && arr[elem+1]<rep && !visited[elem+1]){ printf("1 %d %d\n",elem+2,elem+1);visited[elem+1]=true; if(check(elem+1)) index.push(elem+1); test--; }
 if(check(elem)) index.push(elem);
 }
 return 0;
}

1237A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1237A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int n,m,add=0; scanf("%d",&n);
 for(int i=0; i<n;i++){
 scanf("%d",&m);
 if(m==0) printf("0\n");
 else if(m%2!=0) {
 if(m<0) add++;
 if(m>0) add--;
 if(add==-2 || add==2 ) { printf("%d\n",m/2-(add/2)); add=0;}
 else printf("%d\n",m/2);

 }
 else printf("%d\n",m/2);
 }
 return 0;
}

1237B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1237B

#include <bits/stdc++.h>
using namespace std;

int main(){
 int n,aux,res=0,j=0; scanf("%d",&n);
 vector<int> V,V2;
 for(int i=0; i<n;i++){
 scanf("%d",&aux);
 V.push_back(aux);
 }
 for(int i=0; i<n;i++){
 scanf("%d",&aux);
 V2.push_back(aux);
 }
 bool visited[n+1];
 memset(visited,false,sizeof(visited));
 for(int i=0; i<n && j<n;i++){
 if(visited[V[i]]) continue;
 while(V[i]!=V2[j]) {
 visited[V2[j]]=true;
 //cout<<V2[j]<<endl;
 j++; res++;
 }
 j++;
 visited[V[i]]=true;
 }
 printf("%d\n",res);
 return 0;
}

1237C1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1237C1

#include <bits/stdc++.h>
using namespace std;

struct state{
 int x,y,z;
};

bool inside(state a, state b, state c){
 //min(xa,xb)<=xc≤max(xa,xb), min(ya,yb)<=yc≤max(ya,yb), and min(za,zb)<=zc<=max(za,zb)
 int minx = min(a.x,b.x);
 int maxx = max(a.x,b.x);
 int miny = min(a.y,b.y);
 int maxy = max(a.y,b.y);
 int minz = min(a.z,b.z);
 int maxz = max(a.z,b.z);
 return ((minx<=c.x && c.x<=maxx) && (miny<=c.y && c.y<=maxy) && (minz<=c.z && c.z<=maxz));
}
int main(){
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/in.txt","r",stdin);
 //freopen("C:/Users/Isaac/Documents/QT/Entregar/out.txt","w",stdout);
 int n; scanf("%d",&n);
 vector<state> V;
 for(int i=0; i<n;i++){
 int x,y,z; scanf("%d %d %d",&x,&y,&z); V.push_back(state{x,y,z});
 }
 bool visited[n];
 memset(visited,false,sizeof(visited));
 for(int i=0; i<n; i++){
 if(visited[i]) continue;
 for(int j=0; j<n; j++){
 if(visited[j] || i==j) continue;
 bool flag=false;
 for(int z=0; z<n && flag==false;z++){
 if(visited[z] || z==j || z==i) continue;
 if(inside(V[i],V[j],V[z])) flag=true;
 }
 //cout<<flag<<endl;
 if(!flag) {
 visited[i]=true; visited[j]=true; printf("%d %d\n",i+1,j+1);
 break;
 }
 }
 }

 return 0;
}

1247A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1247A

#include <bits/stdc++.h>
using namespace std;

int main(){
 long long int da,db;
 scanf("%lld %lld",&da,&db);
 if(db>=da+2 || (da>db && (da!=9 || db!=1)) || (db==0 && da==0) ) printf("-1\n");
 else if(db!=da) {
 if(!(da!=9 && db!=1)) printf("9 10\n");
 else printf("%lld %lld\n",da,db);
 }
 else printf("%lld %lld\n",db*10,db*10+1);
 return 0;
}

1247B1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1247B1


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int n,k,d; scanf("%d %d %d",&n,&k,&d);
 int arr[n];
 set<int> S;
 map<int,int> M;
 for(int i=0; i<n;i++) {
 scanf("%d",&arr[i]);
 if(i<d) {
 S.insert(arr[i]);
 M[arr[i]]++;
 }
 }
 int res = S.size();
 for(int i=0; i<n;i++){
 if(M[arr[i]]==1) S.erase(arr[i]);
 M[arr[i]]--;
 if(d+i==n) break;
 S.insert(arr[d+i]);
 M[arr[d+i]]++;
 res = min((int)S.size(),res);
 }
 printf("%d\n",res);
 }
 return 0;
}

1247B2 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1247B2


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int n,k,d; scanf("%d %d %d",&n,&k,&d);
 int arr[n];
 set<int> S;
 map<int,int> M;
 for(int i=0; i<n;i++) {
 scanf("%d",&arr[i]);
 if(i<d) {
 S.insert(arr[i]);
 M[arr[i]]++;
 }
 }
 int res = S.size();
 for(int i=0; i<n;i++){
 if(M[arr[i]]==1) S.erase(arr[i]);
 M[arr[i]]--;
 if(d+i==n) break;
 S.insert(arr[d+i]);
 M[arr[d+i]]++;
 res = min((int)S.size(),res);
 }
 printf("%d\n",res);
 }
 return 0;
}

1248A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1248A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int q; scanf("%d",&q);
 while(q--){
 long long int n; scanf("%lld",&n);
 long long int aux,par,impar; par=impar=0;
 for(long long int i=0; i<n;i++){
 scanf("%lld",&aux);
 if(aux%2==0) par++;
 else impar++;
 }
 long long int m,res=0; scanf("%lld",&m);
 for(long long int i=0; i<m;i++){
 long long int aux; scanf("%lld",&aux);
 if(aux%2==0) res+=par;
 else if(aux%2!=0) res+=impar;
 }
 printf("%lld\n",res);
 }
 return 0;
}

1249A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int q; scanf("%d",&q);
 while(q--){
 int n; scanf("%d",&n);
 vector<int> V2;
 for(int j=0; j<n;j++){
 int num;
 scanf("%d",&num); V2.push_back(num);
 }
 bool flag=false;
 for(int i=0; i<n && !flag;i++)
 for(int j=i+1; j<n && !flag;j++){
 if(abs(V2[i]-V2[j])==1) flag=true;
 }
 if(!flag) printf("1\n");
 else printf("2\n");
 }
 return 0;
}

1249B1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249B1

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 100100;
const int INF = 0x3f3f3f3f;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
};

struct state{
 int node, dist;
 state(){}
 state(int a, int b){
 node = a; dist = b;
 }
 bool operator<(const state &other)const{ // sobrecarga de operadores para ordenar
 return other.dist < dist;
 }
};

vector<edge> graph[MAXN];
int dist[MAXN];

int a=1, b=3;
int N,E;

int dijkstra(int start, int end){
 dist[start] = 0;
 priority_queue<state> pq;
 pq.push(state(start, 0));
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(dist[cur.node] < cur.dist) continue;
 if(cur.node == end) return cur.dist;
 for(int i=0;i<graph[cur.node].size();i++){
 int dest = graph[cur.node][i].to;
 int wht = graph[cur.node][i].weight + cur.dist;
 if(dist[dest] <= wht) continue;
 dist[dest] = wht;
 pq.push(state(dest, wht));
 }
 }
 return -1;
}

int main(){
 int n,m; scanf("%d",&n);
 while(n--){
 scanf("%d",&m);
 N=E=m;
 memset(dist,0x3f,sizeof(dist));
 int arr[m+1];
 for(int i=1;i<=N;i++) graph[i].clear(); // limpia el grafo
 for(int i=1;i<=E;i++){
 int to; scanf("%d",&to); arr[i]=to;
 graph[i].push_back(edge(i,to,1));
 }
 for(int i=1; i<=m;i++) {
 memset(dist,0x3f,sizeof(dist));
 if(i==1) printf("%d",dijkstra(arr[i],i)+1);
 else printf(" %d",dijkstra(arr[i],i)+1);
 }
 printf("\n");
 for(int i=1;i<=N;i++) graph[i].clear();
 }
 return 0;
}

1249B2 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249B2

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 200100;
const int INF = 0x3f3f3f3f;

struct edge{
 int from, to, weight;
 edge(){}
 edge(int a, int b, int c){
 from = a;
 to = b;
 weight = c;
 }
};

struct state{
 int node, dist;
 state(){}
 state(int a, int b){
 node = a; dist = b;
 }
 bool operator<(const state &other)const{ // sobrecarga de operadores para ordenar
 return other.dist < dist;
 }
};

vector<edge> graph[MAXN];
int dist[MAXN];
int check[MAXN];
int index=0;

int N,E;

int dijkstra(int start, int end){
 dist[start] = 0;
 priority_queue<state> pq;
 pq.push(state(start, 0));
 while(!pq.empty()){
 state cur = pq.top(); pq.pop();
 if(dist[cur.node] < cur.dist) continue;
 if(cur.node == end) return cur.dist;
 for(int i=0;i<graph[cur.node].size();i++){
 int dest = graph[cur.node][i].to;
 int wht = graph[cur.node][i].weight + cur.dist;
 if(dist[dest] <= wht) continue;
 dist[dest] = wht;
 check[dest]=index;
 check[cur.node]=index;
 pq.push(state(dest, wht));
 }
 }
 return -1;
}

int main(){
 int n,m; scanf("%d",&n);
 while(n--){
 scanf("%d",&m);
 N=E=m;
 memset(dist,0x3f,sizeof(dist));
 int arr[m+1];
 for(int i=1;i<=N;i++) graph[i].clear(); // limpia el grafo
 for(int i=1;i<=E;i++){
 int to; scanf("%d",&to); arr[i]=to;
 graph[i].push_back(edge(i,to,1));
 }
 memset(check,-1,sizeof(check));
 vector<int> V;
 index=-1;
 memset(dist,0x3f,sizeof(dist));
 for(int i=1; i<=m;i++) {
 //memset(dist,0x3f,sizeof(dist));
 int indexRes;
 if(check[i]==-1) { index++; V.push_back(dijkstra(arr[i],i)+1); indexRes=index; }
 else indexRes=check[i];
 if(i==1) printf("%d",V[indexRes]);
 else printf(" %d",V[indexRes]);
 }
 printf("\n");
 for(int i=1;i<=N;i++) graph[i].clear();
 }
 return 0;
}

1249C1 — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1249C1

#include <bits/stdc++.h>
#define INF
using namespace std;

struct state{
 int curIndex;
 int sum;
};

int main(){
 set<int> S;
 queue<state> Q;
 for(int i=0; i<=9;i++) {state aux; aux.curIndex=i; aux.sum= pow(3,i); Q.push(aux); S.insert(pow(3,i)); }
 while(!Q.empty()){
 state q = Q.front(); Q.pop();
 S.insert(q.sum);
 state aux = q; aux.curIndex++;
 if(aux.curIndex<9) Q.push(aux);
 for(int i=q.curIndex+1; i<=9;i++){
 q.sum+=pow(3,i); q.curIndex=i;
 if(q.sum<20000) Q.push(q);
 else break;
 }
 }

 int q; scanf("%d",&q);
 while(q--){
 int n; scanf("%d",&n);
 for(auto s:S){
 if(s>=n) { printf("%d\n",s); break; }
 }
 }
}

1251A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1251A

#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 string line; cin>>line;
 set<char> S;
 for(unsigned int i=0;i<line.length();i++){
 if(i+1==line.length()) S.insert(line[i]);
 for(unsigned int j=i+1; j<line.length();j++){
 if(line[j]!=line[i] && (j-i)%2!=0) {
 S.insert(line[i]); i=j-1; break;
 }
 else if(line[j]!=line[i]) { i=j-1; break; }
 else if(j+1==line.length()) { if((j-i+1)%2!=0) S.insert(line[i]); i=j+1;}
 }
 }
 for(auto s:S) printf("%c",s);
 printf("\n");
 }
 return 0;
}

1466A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1466A


#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int cases; scanf("%d",&cases);
 while(cases--){
 int trees; scanf("%d",&trees);
 int tree[trees];
 for(int i=0; i<trees; i++) scanf("%d",&tree[i]);
 set<int> S;
 for(int i=0; i<trees; i++)
 for(int j=i+1; j<trees; j++)
 {
 int res = abs(tree[i]-tree[j]);
 S.insert(res);
 }
 printf("%d\n",S.size());
 }
 return 0;
}

1466B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1466B


#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int cases; scanf("%d",&cases);
 while(cases--){
 int notes; scanf("%d",¬es);
 map<int,int> M;
 for(int i=0; i<notes; i++){
 int number; scanf("%d",&number);
 M[number]++;
 }
 for(auto m:M){
 if(m.second<2) continue;
 else{
 M[m.first+1]++;
 M[m.first]--;
 }
 }
 int res = 0;
 for(auto m:M){
 if(m.second!=0) res++;
 }
 printf("%d\n",res);
 }
 return 0;
}

1676A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1676A


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--) {
 string n; cin>>n;
 if(n[0]+n[1]+n[2] == n[3]+n[4]+n[5]) cout<<"YES\n";
 else cout<<"NO\n";
 }
 return 0;
}

1688A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1688A


#include <bits/stdc++.h>
using namespace std;

string bin(long long int n){
 long long int i;
 string res = "0";
 for (i = 1 << 30; i > 0; i = i / 2){
 if((n & i) != 0) res+="1";
 else res+="0";
 }
 return res;
}
int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 long long int number; scanf("%lld",&number);
 string num = bin(number);
 //cout<<num<<endl;
 string res = "";
 int unos=0;
 for(int i=0; i<num.length();i++){
 if(num[i]=='1') unos++;
 }
 if(unos==1){
 for(int i=num.length()-1; i>=0;i--){
 if(num[i]=='0') {
 num[i] = '1';
 break;
 }
 }
 }
 else{
 bool flag = false;
 for(int i=num.length()-1; i>=0;i--){
 if(flag) num[i]='0';
 if(num[i]=='1') {
 flag=true;
 }
 }
 }
 cout<<stoi(num, 0, 2)<<endl;
 }
 return 0;
}

1688B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1688B


#include <bits/stdc++.h>
using namespace std;

string bin(long long int n){
 long long int i;
 string res = "0";
 for (i = 1 << 30; i > 0; i = i / 2){
 if((n & i) != 0) res+="1";
 else res+="0";
 }
 return res;
}

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int n; scanf("%d",&n);
 int pares = 0;
 int impares = 0;
 int minValue = 0x3f3f3f3f;
 for(int i=0; i<n;i++){
 int num; scanf("%d",&num);
 if(num%2==0) pares++;
 else impares++;
 if(num%2==0) {
 string res = bin(num);
 int sum = 0;
 for (int j = res.length() - 1; j >= 0; j--) {
 if (res[j] == '1') break;
 sum++;
 }
 minValue=min(minValue,sum);
 }
 }
 int res = 0;
 if(pares>0) {
 if(impares==0) {
 res += minValue;
 res+= pares-1;
 }
 else
 res+=pares;
 }
 printf("%d\n",res);
 }
 return 0;
}

1690A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1690A


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int num; scanf("%d",&num);
 int h1 = num/3-1;
 int h2 = num/3;
 int h3 = num/3-2;
 int remaining = num-h1-h2-h3;
 for(int i=0; i<remaining;i++){
 if(i%3==0) h2++;
 if(i%3==1) h1++;
 if(i%3==2) h3++;
 }
 if((h1+h2+h3)!=num) cout<<"ERROR\n";
 printf("%d %d %d\n",h1,h2,h3);
 }
 return 0;
}

1690B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1690B


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; int n;
 scanf("%d",&cases);
 while(cases--){
 scanf("%d",&n); int a1[n],b1[n];
 for(int i=0; i<n;i++) scanf("%d",&a1[i]);
 int diff = 0;
 for(int i=0; i<n;i++) {
 scanf("%d",&b1[i]);
 if(b1[i]==0) diff=max(diff,a1[i]);
 else diff=max(diff,a1[i]-b1[i]);
 }
 bool flag = true;
 for(int i=0; i<n;i++) {
 if(b1[i]==0 && diff<a1[i]) flag = false;
 if(b1[i]!=0 && diff!=(a1[i]-b1[i])) flag=false;
 }
 if(flag) printf("YES\n");
 else printf("NO\n");
 }
 return 0;
}

1690C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1690C


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int n; scanf("%d",&n);
 int s[n],f[n];
 int time = 0;
 for(int i=0; i<n;i++) scanf("%d",&s[i]);
 for(int i=0; i<n;i++) scanf("%d",&f[i]);
 for(int i=0; i<n;i++){
 if(i==0){
 time = f[i];
 printf("%d",f[i]-s[i]);
 } else{
 time = max(s[i],time);
 if(time>f[i]) printf(" 0");
 else printf(" %d",f[i]-time);
 time = max(f[i],time);
 }
 }
 printf("\n");
 }
 return 0;
}

1690D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1690D


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--){
 int n,k; scanf("%d %d",&n,&k);
 string line; cin>>line;
 int res = 0,finalRes=0;
 for(int i=0; i<k;i++){
 if(line[i]=='W') res++;
 }
 finalRes = res;
 for(int i=k; i<line.length();i++){
 if(line[i-k]=='W') res--;
 if(line[i]=='W') res++;
 finalRes = min(finalRes,res);
 }
 printf("%d\n",finalRes);
 }
 return 0;
}

1691A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1691A


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--) {
 int n, res = 0;
 scanf("%d", &n);
 int num;
 for (int i = 0; i < n; i++){
 cin>>num;
 if (num % 2) res++;
 }
 cout<<min(res, n - res)<<endl;
 }
 return 0;
}

1691B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1691B


#include <bits/stdc++.h>
using namespace std;

int main(){
 int cases; scanf("%d",&cases);
 while(cases--) {
 int n; cin>>n;
 int res[n+5],last,current,lastIndex=1;
 int numEquals = 0;
 bool valid = true;
 scanf("%d",&last);
 if(n==1) valid=false;
 for(int i=1; i<n;i++){
 scanf("%d",¤t);
 if(current==last){
 numEquals++;
 res[i-1]=i+1;
 }
 else if(numEquals==0) valid=false;
 else {
 last=current;
 res[i-1]=lastIndex;
 lastIndex=i+1;
 numEquals=0;
 }
 if(current==last && i+1==n && numEquals!=0){
 res[i]=lastIndex;
 }
 if(current==last && i+1==n && numEquals==0) valid=false;
 }
 if(valid){
 for(int i=0; i<n;i++) {
 if(i==0) printf("%d",res[i]);
 else printf(" %d",res[i]);
 }
 printf("\n");
 }
 else printf("-1\n");
 }
 return 0;
}

1A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 1A

#include <iostream>
using namespace std;

int main() {
 long long int a,n,m;
 cin>>n>>m>>a;
 cout<< ((n+a-1)/a)*((m+a-1)/a) <<endl;
 return 0;
}

226A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 226A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 11:58:41
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n,index=0,res=0; scanf("%d",&n); cin.ignore();
 string a; cin>>a;
 for(unsigned int i=1; i<a.length();i++){
 if(a[index]==a[i]) res++;
 else index++;
 }
 printf("%d",res);
 return 0;
}

228A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 228A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 19:04:37
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 set<int> S;
 int a,b,c,d; scanf("%d %d %d %d",&a,&b,&c,&d); S.insert(a); S.insert(b); S.insert(c); S.insert(d);
 printf("%d",4-S.size());
 return 0;
}

263A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 263A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 18:43:56
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int a,b,n;
 for(int i=0; i<5;i++)
 for(int j=0; j<5;j++) {
 scanf("%d",&n);
 if(n==1) { a=i; b=j;}
 }
 printf("%d",abs(2-a)+abs(2-b));
 return 0;
}

265A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 265A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 19:08:47
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 string a,b;
 cin>>a>>b;
 int res=0;
 for(unsigned int i=0; i<b.length();i++){
 if(a[res]==b[i]) res++;
 }
 printf("%d",res+1);
 return 0;
}

266A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 266A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 11:58:41
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n,index=0,res=0; scanf("%d",&n); cin.ignore();
 string a; cin>>a;
 for(unsigned int i=1; i<a.length();i++){
 if(a[index]==a[i]) res++;
 else index=i;
 }
 printf("%d",res);
 return 0;
}

268A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 268A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 18:35:21
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n,res=0; scanf("%d",&n);
 vector<pair<int,int>> V;
 for(int i=0; i<n;i++){
 int a,b; scanf("%d %d",&a,&b);
 V.push_back({a,b});
 }
 for(int i=0; i<n;i++)
 {
 for(int j=i+1; j<n;j++){
 if(V[i].first==V[j].second) res++;
 if(V[i].second==V[j].first) res++;
 }
 }
 printf("%d",res);
 return 0;
}

294A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 294A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 19:26:45
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n,n2; scanf("%d",&n);
 int arr[n];
 for(int i=0; i<n;i++) scanf("%d",&arr[i]);
 scanf("%d",&n2);
 for(int i=0; i<n2;i++){
 int bird,line;
 scanf("%d %d",&line,&bird);
 if(line==n){
 arr[line-2]+=bird-1;
 }
 else{
 arr[line]+=arr[line-1]-bird;
 arr[line-2]+=bird-1;
 }
 arr[line-1]=0;
 }
 for(int i=0; i<n;i++){
 printf("%d\n",arr[i]);
 }
 return 0;
}

339A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 339A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-04 16:45:07
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 string line; cin>>line;
 vector<int> V;
 for(unsigned int i=0; i<line.length();i++){
 if(line[i]=='+') continue;
 V.push_back(line[i]-'0');
 }
 sort(V.begin(),V.end());
 for(unsigned int i=0; i<V.size();i++){
 if(i==0) printf("%d",V[i]);
 else printf("+%d",V[i]);
 }
 return 0;
}

381A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 381A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 11:46:56
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n; scanf("%d",&n);
 int arr[n];
 for(int i=0; i<n;i++){
 scanf("%d",&arr[i]);
 }
 int j=n-1;
 int f=0,resA,resB; resA=resB=0;
 for(int i=0; i<n;i++){
 if(arr[f]>arr[j]){
 if(i%2==0) resA+=arr[f];
 else resB+=arr[f];
 f++;
 }
 else{
 if(i%2==0) resA+=arr[j];
 else resB+=arr[j];
 j--;
 }
 }
 printf("%d %d",resA,resB);
 return 0;
}

427A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 427A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 13:37:41
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n; scanf("%d",&n);
 int res=0,acu=0,aux;
 for(int i=0; i<n;i++){
 scanf("%d",&aux);
 acu+=aux;
 if(acu<0) { acu=0; res++; }
 }
 printf("%d",res);
 return 0;
}

431A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 431A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 13:42:22
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int a[4],res=0;
 scanf("%d %d %d %d",&a[0],&a[1],&a[2],&a[3]);
 string b; cin>>b;
 for(unsigned int i=0; i<b.length();i++){
 res+=a[b[i]-'0'-1];
 }
 printf("%d",res);

 return 0;
}

443A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 443A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-04 00:08:41
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 string line; getline(cin,line);
 set<int> S;
 for(unsigned int i=0; i<line.length();i++){
 if(line[i]=='{'||line[i]=='}'||line[i]==' '||line[i]==',') continue;
 S.insert(line[i]);
 }
 printf("%d",S.size());
 return 0;
}

490A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 490A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-04 16:49:55
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n; scanf("%d",&n);
 vector<int> V[3];
 for(int i=0; i<n;i++){
 int val; scanf("%d",&val);
 V[val-1].push_back(i+1);
 }
 int minValue = min(V[0].size(),min(V[2].size(),V[1].size()));
 printf("%d\n",minValue);
 for(int i=0; i<minValue;i++){
 printf("%d %d %d\n",V[0][i],V[1][i],V[2][i]);
 }
 return 0;
}

4A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 4A

#include <iostream>
using namespace std;

int main() {
 int a;
 cin>>a;
 if(a&1||a<4)
 cout<<"NO\n";
 else
 cout<<"YES\n";
 return 0;
}

686A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 686A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-04 16:33:34
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 long long int n,total,no=0; scanf("%lld %lld",&n,&total);
 char c;
 for(int i=0; i<n;i++){
 cin.ignore();
 long long int aux;
 scanf("%c %lld",&c,&aux);
 if(c=='-' && aux>total ) no++;
 else if(c=='-') total-=aux;
 else total+=aux;
 }
 printf("%lld %lld",total,no);
 return 0;
}

709A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 709A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-03 23:23:59
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n,b,d,acu=0,res=0; scanf("%d %d %d",&n,&b,&d);
 for(int i=0; i<n;i++){
 int aux; scanf("%d",&aux);
 if(aux>b) continue;
 acu+=aux;
 if(acu>d) { res++; acu=0; }
 }
 printf("%d\n",res);
 return 0;
}

71A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 71A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-04 00:17:46
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int cases; scanf("%d",&cases);
 while(cases--){
 string a; cin>>a;
 if(a.length()>10) cout<<a[0]<<a.length()-2<<a[a.length()-1]<<'\n';
 else cout<<a<<'\n';
 }
 return 0;
}

731A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 731A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 13:49:14
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 string a; cin>>a;
 int res = 0;
 char c = 'a';
 for(unsigned int i=0; i<a.length();i++){
 res+=min(abs(c-a[i]),26-abs(c-a[i]));
 c=a[i];
 }
 printf("%d",res);
 return 0;
}

732A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 732A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 18:48:14
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 long long int price,coin,res=1,acu; scanf("%lld %lld",&price,&coin); acu=price;
 while(1){
 if(acu%10==0) break;
 if(acu==coin) break;
 else if((acu-coin)>0&&(acu-coin)%10==0) break;
 acu+=price;
 /*cout<<acu-coin<<endl;
 cout<<acu<<endl;
 cout<<"---"<<endl;*/
 res++;
 }
 printf("%lld",res);
 return 0;
}

770A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 770A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-04 17:03:47
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 int n,k; scanf("%d %d",&n,&k);
 int flag = 0; k--;
 for(int i=0; i<n;i++){
 if(k>=0) printf("%c",'a'+k);
 else {
 if(flag==0) printf("%c",'b');
 else printf("%c",'a');
 flag++; flag%=2;
 }
 k--;
 }
 return 0;
}

799A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 799A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-11-03 23:30:04
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int main() {
 //N total cakes, t time per round, k max round, d time to create second oven
 int n,t,k,d; scanf("%d %d %d %d",&n,&t,&k,&d);
 int aux=d;
 while(aux>=0){
 n-=k;
 aux-=t;
 }
 if((n>0 && aux<0)||(aux==0 && n>=aux+1)) printf("YES\n");
 else printf("NO\n");
 return 0;
}

910A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 910A

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int n,j;
string flowers;
int memo[105][105];

int dp(int pos, int dist)
{
 if(pos==n-1) return dist;
 int &best = memo[pos][dist];
 if(memo[pos][dist]!=-1) return best;
 int val = INF;
 for(int i=1; i<=j && pos+i<n;i++)
 if(flowers[i+pos]=='1') val=min(val,dp(i+pos,dist+1));
 return best=val;
}
int main()
{
 scanf("%d%d",&n,&j);
 memset(memo,-1,sizeof(memo));
 cin.ignore();
 getline(cin,flowers);
 int res = dp(0,0);
 if(res!=INF) printf("%d\n",res);
 else printf("-1\n");
 return 0;
}

913A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 913A

#include <bits/stdc++.h>
using namespace std;
int main()
{
 long long int a,b;
 cin>>a>>b;
 a=pow(2,a);
 cout<<b%a<<endl;
 return 0;
}

914A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 914A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
bool PerfectSquare(int n) {
 if (n < 0)
 return false;
 int root = (int) sqrt(n);
 return n == root * root;
}
int main()
{
 int a,b;
 while(scanf("%d",&a)==1)
 {
 int res=-INF;
 for(int i=0; i<a;i++)
 {
 cin>>b;
 if(!PerfectSquare(b))
 res=max(res,b);

 }
 cout<<res<<endl;
 }
 return 0;
}

917A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 917A

#include<bits/stdc++.h>
using namespace std;
int main() {
 int ans = 0;
 string in;
 cin>>in;
 for (unsigned int i = 0; i < in.length(); i++) {
 int l = 0, r = 0;
 for (unsigned int j = i; j < in.length(); j++) {
 if (in[j] == '(') l++, r++;
 if (in[j] == ')') l--, r--;
 if (in[j] == '?') l--, r++;
 if (r < 0) break;
 if (l < 0) l += 2;
 if (l <= 0 && r >= 0 && r % 2 == 0) ans++;
 }
 }
 printf("%d\n", ans);
 return 0;
}

918A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 918A

#include <bits/stdc++.h>
using namespace std;
int main()
{
 int num,aux=1,a=1;
 cin>>num;
 char arr[num];
 memset(arr,'o',sizeof(arr));
 while(aux<=num){
 arr[aux-1]='O';
 int t = aux;
 aux+=a;
 a=t;
 }
 for(int i=0; i<num;i++)
 {
 cout<<arr[i];
 }
 cout<<endl;
 return 0;
}

918B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 918B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
struct IP{
 string name;
 string ip;
};
int main() {
 //freopen("C:/Users/Isaac/Desktop/in.txt","r",stdin);
 //freopen("C:/Users/Isaac/Desktop/out.txt","w",stdout);
 int n,m;
 vector<IP> name;
 string aux,action;
 IP a;
 cin>>n>>m;
 for(int i=0; i<n;i++) {cin>>aux; a.name=aux; cin>>aux;aux+=';'; a.ip=aux; name.push_back(a);}
 for(int i=0; i<m;i++) {
 cin>>action>>aux;
 for(int j=0; j<n;j++)
 {
 if(name[j].ip==aux)
 {
 cout<<action<<" "<<name[j].ip<<" #"<<name[j].name<<endl;
 break;
 }
 }
 }
 return 0;
}

919A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 919A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 double a,b,n,c,res=INF;
 cin>>n>>c;
 while(n--)
 {
 cin>>a>>b;
 res=min(res,(c*a)/b);
 }
 printf("%.8lf\n",res);
 return 0;
}

919B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 919B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main() {
 int i=18,ans=0,n;
 cin>>n;
 while (i++)
 {
 int x=i,sm=0;
 while (x) {sm+=x%10;x/=10;} //sum of the number
 if (sm==10) {ans++;if (ans==n) {cout<<i;break;}}
 }
 return 0;
}

919C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 919C

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int main() {
 int n,m,c,res=0,count=0;
 cin>>n>>m>>c;
 char arr[n][m];
 bool flag=false;
 for(int i=0; i<n;i++)
 for(int j=0; j<m;j++) cin>>arr[i][j];
 //row
 for(int i=0; i<n;i++)
 {
 for(int j=0;j<m;j++)
 {
 if(flag) if(arr[i][j]=='.') count++; else {count=0; flag=false;}
 else if(arr[i][j]=='.') {flag=true; count++;};
 if(count>=c) res++;
 }
 flag=false; count=0;
 }
 count=0; flag=false;
 //column
 for(int i=0; i<m;i++)
 {
 for(int j=0;j<n;j++)
 {
 if(flag) if(arr[j][i]=='.') count++; else {count=0; flag=false;}
 else if(arr[j][i]=='.') {flag=true; count++;};
 if(count>=c) res++;
 }
 flag=false; count=0;
 }
 if(c==1) res/=2;
 cout<<res<<endl;
 return 0;
}

935A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 935A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;


int main()
{
 long long int num,res=0;
 cin>>num;
 for(int i=1; i<num;i++)
 if(num%i==0)res++;
 cout<<res<<'\n';
}

935B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 935B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int num,m=0,j=0,res=0,flag=0;
 char aux1 = 'Z';
 cin>>num;
 string aux;
 cin>>aux;
 for(int i=0; i<aux.length();i++)
 {
 if(flag==1) { if(aux[i]!=aux1)res--; flag=0; }
 if(aux[i]=='U') m++;
 else j++;
 if(j==m && i!=aux.length()-1) { res++; aux1=aux[i]; flag=1; }
 }
 cout<<res<<endl;
 return 0;
}

939A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 939A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 int cases,flag=0;
 cin>>cases;
 int arr[cases];
 int aux1[3],aux[3];
 for(int i=0; i<cases;i++)
 cin>>arr[i];
 for(int i=0; i<cases;i++)
 {
 aux[0] = arr[i];
 aux1[0] = i+1;
 aux[1] = arr[arr[i]-1];
 aux1[1]= arr[i];
 aux[2] = arr[arr[arr[i]-1]-1];
 aux1[2] = arr[arr[i]-1];
 sort(aux,aux+3);
 sort(aux1,aux1+3);
 if(aux[0]==aux1[0]&&aux[1]==aux1[1]&&aux[2]==aux1[2]) {flag=1; break;}
 }
 if(flag==1) cout<<"YES\n";
 else cout<<"NO\n";
 return 0;
}

939B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 939B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 long long int h,b,aux,maxi=0,type=1,out=0;
 cin>>h>>b;
 for(long long int i=0; i<b;i++)
 {
 cin>>aux;
 long long int res = h/aux;
 long long int auxres = res*aux;
 if(maxi<auxres) {type=i+1; maxi=auxres; out=res;}
 }
 cout<<type<<" "<<out<<endl;
 return 0;
}

939C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 939C

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main()
{
 long long int cases,s,f,sum=0,k=1,msum,ans=1;
 cin>>cases;
 long long int arr[cases+1];
 for(int i=1; i<=cases;i++) cin>>arr[i];
 cin>>s>>f;
 for (int i=s; i<f; i++) sum+=arr[i];
 msum=sum;
 for (int i=s-1; k<=cases; i--)
 {
 k++;
 if (i<1) i=cases;
 sum+=arr[i];
 int last=(i+(f-s))%cases==0?cases:(i+(f-s))%cases;
 sum-=arr[last];
 if (sum>msum)
 {
 ans=k;
 msum=sum;
 }
 }
 cout<<ans<<endl;
 return 0;
}

940A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 940A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int n,d,a[101],ans=INF;
int main(){
 cin>>n>>d;
 for(int i=1;i<=n;i++) cin>>a[i];
 for(int l=1;l<=100;l++){
 int now=0;
 for(int j=1;j<=n;j++)
 if(a[j]<l||a[j]>l+d) now++;
 if(now<ans) ans=now;
 }
 cout<<ans;
 return 0;
}

940B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 940B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;
int n,k,a,b;
int main()
{
 long long int n,k,a,b;
 long long int ans=0;
 cin>>n>>k>>a>>b;
 while(n>1) {
 ans+=n%k*a;
 n-=n%k;
 if((n-n/k)*a>=b){ n/=k;ans+=b;}
 else {
 ans+=(n-1)*a;
 break;
 }
 }
 cout<<ans<<endl;
 return 0;
}

977A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 977A

#include <bits/stdc++.h>
using namespace std;

int main() {
 long long int a,b; cin>>a>>b;
 while(b--)
 {
 if(a%10!=0) a-=1;
 else a/=10;
 }
 cout<<a<<endl;
 return 0;
}

977B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 977B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 int a,res=0; cin>>a;
 string aux; cin>>aux;
 map<pair<char,char>,int> M;
 for(unsigned int i=1;i<aux.length();i++)
 M[make_pair(aux[i-1],aux[i])]++;
 pair<char,char> p;
 for(auto m:M)
 {
 if(m.second > res)
 {
 p = m.first; res=m.second;
 }
 }
 cout<<p.first<<p.second<<endl;
 return 0;
}

977C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 977C

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 int n,m; cin>>n>>m;
 int a[n+2];
 a[0]=1; a[n+1]=1000000001;
 for (int i=1;i<=n;i++) cin>>a[i];
 sort(a,a+n+2);
 if (a[m]==a[m+1]) cout<<-1; else cout<<a[m];
 return 0;
}

977D — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 977D

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 map<int, set<long long int> > M;
 int n; cin>>n;
 while(n--) {
 long long int ret; scanf("%lld", &ret);
 long long int now = ret, cnt = 0;
 while(now % 3 == 0) { now /= 3; cnt++; }
 M[cnt].emplace(ret);
 }
 for(auto it = M.rbegin(); it != M.rend(); ++it) {
 for(auto x : it->second) printf("%lld ", x);
 }
 return 0;
}

978A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 978A

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 int cases; cin>>cases;
 map<int,int> M;
 map<int,int> Ma;
 for(int i=0; i<cases;i++) {int au; cin>>au; M[au]=i;}
 int flag=1;
 for(auto m:M) Ma[m.second]=m.first;
 cout<<M.size()<<endl;
 for(auto m:Ma) if(flag==1){flag=0; cout<<m.second;} else cout<<" "<<m.second;
 return 0;
}

978B — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 978B

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 int cases; cin>>cases;
 string va; cin>>va;
 int res = 0,cx=0;
 for(int i=0; i<cases;i++)
 {
 if(va[i]=='x') cx++;
 else { if(cx>2) res+=cx-2; cx=0;}
 }
 if(cx>2) res+=cx-2;
 cout<<res;
 return 0;
}

978C — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 978C

#include <bits/stdc++.h>
#define INF 0x3F3F3F3F
using namespace std;

int main() {
 long long int n,l; cin>>n>>l;
 long long int arr[n+1]; arr[0]=0;
 for(int i =1 ; i<=n;i++) if(i==0) cin>>arr[i]; else {cin>>arr[i]; arr[i]+=arr[i-1];}
 for(int i=0; i<l;i++)
 {
 long long int nu,l=0,h=n; cin>>nu;
 while (l <= h)
 {
 int m = l + (h-l)/2;
 if (arr[m-1]<nu&&nu<=arr[m]) {cout<<m<<" "<<nu-arr[m-1]<<endl; break;}
 if (arr[m] < nu) l = m + 1;
 else h = m - 1;
 }
 }
 return 0;
}

982A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 982A

#include <bits/stdc++.h>
using namespace std;

int main()
{
 int n; string s;
 cin>>n>>s;
 s="0"+s+"0";
 if (s.find("000")==-1 && s.find("11")==-1) cout<<"Yes\n";
 else cout<<"No\n";
 return 0;
}

9A — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — 9A

/* Visit: https://isaaclo97.github.io/Programacion.html
 * Author: isaaclo97
 * Time: 2019-10-27 19:17:31
**/

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

int gcd(int a, int b) {
while (b > 0) {
int temp = b; b = a % b; a = temp; }
return a; }
int lcm(int a, int b){ return a*(b/gcd(a,b));}

int main() {
 int n,m; scanf("%d %d",&n,&m); n=max(n,m);
 int aux = gcd(7-n,6);
 printf("%d/%d",(7-n)/aux,6/aux);
 return 0;
}

CODEFORCESEFISHERMEN — Codeforces

Mon, 01 Jan 0001 00:00:00 +0000

Solución — CODEFORCESEFISHERMEN

#include <bits/stdc++.h>
using namespace std;

bool compare(pair<int,int> A, pair<int,int> B)
{
 return A.second<B.second;
}

vector<pair<int,int>> V;
vector<pair<int,int>> P;
vector<int> Paux;
int n,m,l;

int bb(int x)
{
 int first = 0, middle, last = m;
 int searched = x;
 while (first<=last) { middle = (first + last) / 2;
 if (searched == P[middle].second) return middle;
 else {
 if (P[middle].second > searched) last = middle - 1;
 else first = middle + 1;
 }
 }
 return middle+1;
}
int main()
{
 scanf("%d%d%d",&n,&m,&l);
 for(int i=0; i<n;i++)
 {
 int x,y; scanf("%d%d",&x,&y);
 V.push_back({x,y});
 }

 int marcas[m+1]; memset(marcas,0,sizeof(marcas));
 int sol[m+1]; memset(sol,0,sizeof(sol));
 for(int i=0; i<m;i++)
 {
 int k;
 scanf("%d",&k);
 P.push_back({i,k});
 Paux.push_back(k);
 }
 sort(P.begin(),P.end(),compare);
 sort(Paux.begin(),Paux.end());
 for(int i=0; i<n;i++)
 {
 int x,y; x=V[i].first; y=V[i].second;
 int aux = l-y;
 if(aux<0) continue;
 if(aux==0)
 {
 //bbinaria pescadores con x
 int res = bb(x);
 if(P[res].second == x) {
 marcas[res]++;
 marcas[res+1]--;
 }
 continue;
 }
 int infer = x-aux;
 int super = x+aux;
 vector<int>::iterator low,up;
 low=std::lower_bound (Paux.begin(), Paux.end(),infer);
 up= std::upper_bound (Paux.begin(), Paux.end(),super);
 int resi = (low- Paux.begin());
 int ress = (up - Paux.begin());
 if(ress==m) marcas[m]--;
 if(P[ress].second==super) marcas[ress+1]--;
 else marcas[ress]--;
 marcas[resi]++;
 }
 int flag = 0;
 for(int i=0; i<m;i++)
 {
 //printf("M: %d\n",marcas[i]);
 flag+=marcas[i];
 sol[i]=flag;
 }
 int solv[m+1];
 for(int i=0; i<m;i++)
 {
 solv[P[i].first] = sol[i];
 }
 for(int i=0; i<m;i++)
 {
 printf("%d\n",solv[i]);
 }
 return 0;
}