├── C ├── Iniciante │ ├── 1001 │ │ └── 1001.c │ ├── 1002 │ │ └── 1002.c │ ├── 1003 │ │ └── 1003.c │ ├── 1004 │ │ └── 1004.c │ ├── 1005 │ │ └── 1005.c │ ├── 1006 │ │ └── 1006.c │ ├── 1007 │ │ └── 1007.c │ ├── 1008 │ │ └── 1008.c │ ├── 1009 │ │ └── 1009.c │ ├── 1010 │ │ └── 1010.c │ ├── 1011 │ │ └── 1011.c │ ├── 1012 │ │ └── 1012.c │ ├── 1013 │ │ └── 1013.c │ ├── 1014 │ │ └── 1014.c │ ├── 1015 │ │ └── 1015.c │ ├── 1016 │ │ └── 1016.c │ ├── 1017 │ │ └── 1017.c │ ├── 1019 │ │ └── 1019.c │ ├── 1020 │ │ └── 1020.c │ ├── 1035 │ │ └── 1035.c │ ├── 1036 │ │ └── 1036.c │ ├── 1037 │ │ └── 1037.c │ ├── 1038 │ │ └── 1038.c │ ├── 1041 │ │ └── 1041.c │ ├── 1043 │ │ └── 1043.c │ ├── 1044 │ │ └── 1044.c │ ├── 1046 │ │ └── 1046.c │ ├── 1047 │ │ └── 1047.c │ ├── 1048 │ │ └── 1048.c │ ├── 1050 │ │ └── 1050.c │ ├── 1059 │ │ └── 1059.c │ ├── 1060 │ │ └── 1060.c │ ├── 1064 │ │ └── 1064.c │ ├── 1065 │ │ └── 1065.c │ ├── 1067 │ │ └── 1067.c │ ├── 1070 │ │ └── 1070.c │ ├── 1071 │ │ └── 1071.c │ ├── 1072 │ │ └── 1072.c │ ├── 1073 │ │ └── 1073.c │ ├── 1074 │ │ └── 1074.c │ ├── 1075 │ │ └── 1075.c │ ├── 1078 │ │ └── 1078.c │ ├── 1079 │ │ └── 1079.c │ ├── 1080 │ │ └── 1080.c │ ├── 1095 │ │ └── 1095.c │ ├── 1096 │ │ └── 1096.c │ ├── 1097 │ │ └── 1097.c │ ├── 1098 │ │ └── 1098.c │ ├── 1099 │ │ └── 1099.c │ ├── 1101 │ │ └── 1101.c │ ├── 1113 │ │ └── 1113.c │ ├── 1114 │ │ └── 1114.c │ ├── 1115 │ │ └── 1115.c │ ├── 1116 │ │ └── 1116.c │ ├── 1117 │ │ └── 1117.c │ ├── 1132 │ │ └── 1132.c │ ├── 1133 │ │ └── 1133.c │ ├── 1134 │ │ └── 1134.c │ ├── 1142 │ │ └── 1142.c │ ├── 1143 │ │ └── 1143.c │ ├── 1144 │ │ └── 1144.c │ ├── 1145 │ │ └── 1145.c │ ├── 1146 │ │ └── 1146.c │ ├── 1149 │ │ └── 1149.c │ ├── 1150 │ │ └── 1150.c │ ├── 1151 │ │ └── 1151.c │ ├── 1153 │ │ └── 1153.c │ ├── 1154 │ │ └── 1154.c │ ├── 1155 │ │ └── 1155.c │ ├── 1156 │ │ └── 1156.c │ ├── 1157 │ │ └── 1157.c │ ├── 1158 │ │ └── 1158.c │ ├── 1159 │ │ └── 1159.c │ ├── 1160 │ │ └── 1160.c │ ├── 1164 │ │ └── 1164.c │ ├── 1165 │ │ └── 1165.c │ ├── 1172 │ │ └── 1172.c │ ├── 1173 │ │ └── 1173.c │ ├── 1174 │ │ └── 1174.c │ ├── 1175 │ │ └── 1175.c │ ├── 1176 │ │ └── 1176.c │ ├── 1177 │ │ └── 1177.c │ ├── 1178 │ │ └── 1178.c │ ├── 1180 │ │ └── 1180.c │ ├── 1181 │ │ └── 1181.c │ ├── 1182 │ │ └── 1182.c │ ├── 1183 │ │ └── 1183.c │ ├── 1184 │ │ └── 1184.c │ ├── 1185 │ │ └── 1185.c │ ├── 1186 │ │ └── 1186.c │ ├── 1187 │ │ └── 1187.c │ ├── 1188 │ │ └── 1188.c │ ├── 1190 │ │ ├── matriz.png │ │ └── 1190.c │ ├── 1541 │ │ └── 1541.c │ ├── 1564 │ │ └── 1564.c │ ├── 1589 │ │ └── 1589.c │ ├── 1759 │ │ └── 1759.c │ ├── 1837 │ │ └── 1837.c │ ├── 1847 │ │ └── 1847.c │ ├── 1848 │ │ └── 1848.c │ ├── 1858 │ │ └── 1858.c │ ├── 1864 │ │ └── 1864.c │ ├── 1865 │ │ └── 1865.c │ ├── 1866 │ │ └── 1866.c │ ├── 1914 │ │ └── 1914.c │ ├── 1924 │ │ └── 1924.c │ ├── 1929 │ │ └── 1929.c │ ├── 1930 │ │ └── 1930.c │ ├── 1933 │ │ └── 1933.c │ ├── 1957 │ │ └── 1957.c │ ├── 1958 │ │ └── 1958.c │ ├── 1959 │ │ └── 1959.c │ ├── 1961 │ │ └── 1961.c │ ├── 1962 │ │ └── 1962.c │ ├── 1963 │ │ └── 1963.c │ ├── 1983 │ │ └── 1983.c │ ├── 1984 │ │ └── 1984.c │ ├── 1985 │ │ └── 1985.c │ ├── 2003 │ │ └── 2003.c │ ├── 2006 │ │ └── 2006.c │ ├── 2028 │ │ └── 2028.c │ ├── 2029 │ │ └── 2029.c │ ├── 2057 │ │ └── 2057.c │ ├── 2059 │ │ └── 2059.c │ ├── 2060 │ │ └── 2060.c │ ├── 2061 │ │ └── 2061.c │ ├── 2140 │ │ └── 2140.c │ ├── 2143 │ │ └── 2143.c │ ├── 2146 │ │ └── 2146.c │ ├── 2147 │ │ └── 2147.c │ ├── 2152 │ │ └── 2152.c │ ├── 2159 │ │ └── 2159.c │ ├── 2160 │ │ └── 2160.c │ ├── 2161 │ │ └── 2161.c │ ├── 2164 │ │ └── 2164.c │ ├── 2165 │ │ └── 2165.c │ ├── 2166 │ │ └── 2166.c │ ├── 2167 │ │ └── 2167.c │ ├── 2168 │ │ └── 2168.c │ ├── 2172 │ │ └── 2172.c │ ├── 2176 │ │ └── 2176.c │ ├── 2203 │ │ └── 2203.c │ ├── 2221 │ │ └── 2221.c │ ├── 2234 │ │ └── 2234.c │ ├── 2235 │ │ └── 2235.c │ ├── 2311 │ │ └── 2311.c │ ├── 2334 │ │ └── 2334.c │ ├── 2344 │ │ └── 2344.c │ ├── 2483 │ │ └── 2483.c │ ├── 2510 │ │ └── 2510.c │ ├── 2523 │ │ └── 2523.c │ ├── 2533 │ │ └── 2533.c │ ├── 2534 │ │ └── 2534.c │ ├── 2540 │ │ └── 2540.c │ ├── 2543 │ │ └── 2543.c │ ├── 2544 │ │ └── 2544.c │ ├── 2547 │ │ └── 2547.c │ ├── 2551 │ │ └── 2551.c │ ├── 2581 │ │ └── 2581.c │ ├── 2670 │ │ └── 2670.c │ ├── 2685 │ │ └── 2685.c │ ├── 2702 │ │ └── 2702.c │ ├── 2708 │ │ └── 2708.c │ ├── 2715 │ │ └── 2715.c │ ├── 2717 │ │ └── 2717.c │ ├── 2718 │ │ └── 2718.c │ ├── 2721 │ │ └── 2721.c │ ├── 2747 │ │ └── 2747.c │ ├── 2748 │ │ └── 2748.c │ ├── 2752 │ │ └── 2752.c │ ├── 2753 │ │ └── 2753.c │ ├── 2754 │ │ └── 2754.c │ ├── 2755 │ │ └── 2755.c │ ├── 2756 │ │ └── 2756.c │ ├── 2757 │ │ └── 2757.c │ ├── 2759 │ │ └── 2759.c │ ├── 2761 │ │ └── 2761.c │ ├── 2762 │ │ └── 2762.c │ ├── 2763 │ │ └── 2763.c │ ├── 2764 │ │ └── 2764.c │ ├── 2765 │ │ └── 2765.c │ ├── 2766 │ │ └── 2766.c │ ├── 2770 │ │ └── 2770.c │ ├── 2774 │ │ └── 2774.c │ ├── 2779 │ │ └── 2779.c │ ├── 2782 │ │ └── 2782.c │ ├── 2786 │ │ └── 2786.c │ ├── 2791 │ │ └── 2791.c │ ├── 2802 │ │ └── 2802.c │ ├── 2807 │ │ └── 2807.c │ ├── 2808 │ │ └── 2808.c │ ├── 2823 │ │ └── 2823.c │ ├── 2826 │ │ └── 2826.c │ ├── 2845 │ │ └── 2845.c │ ├── 2846 │ │ └── 2846.c │ ├── 2850 │ │ └── 2850.c │ ├── 2861 │ │ └── 2861.c │ ├── 2862 │ │ └── 2862.c │ ├── 2863 │ │ └── 2863.c │ ├── 2867 │ │ └── 2867.c │ ├── 2879 │ │ └── 2879.c │ ├── 2880 │ │ └── 2880.c │ ├── 2896 │ │ └── 2896.c │ ├── 2950 │ │ └── 2950.c │ ├── 2963 │ │ └── 2963.c │ ├── 2968 │ │ └── 2968.c │ ├── 2982 │ │ └── 2982.c │ ├── 2987 │ │ └── 2987.c │ ├── 3039 │ │ └── 3039.c │ ├── 3040 │ │ └── 3040.c │ ├── 3046 │ │ └── 3046.c │ ├── 3047 │ │ └── 3047.c │ ├── 3055 │ │ └── 3055.c │ ├── 3065 │ │ └── 3065.c │ ├── 3076 │ │ └── 3076.c │ ├── 3084 │ │ └── 3084.c │ └── 3091 │ │ └── 3091.c └── Strings │ ├── 1238 │ └── 1238.c │ ├── 1253 │ └── 1253.c │ ├── 1257 │ └── 1257.c │ ├── 1272 │ └── 1272.c │ ├── 1274 │ └── 1274.c │ ├── 1305 │ └── 1305.c │ ├── 1332 │ └── 1332.c │ ├── 1607 │ └── 1607.c │ ├── 1632 │ └── 1632.c │ ├── 1871 │ └── 1871.c │ ├── 2025 │ └── 2025.c │ ├── 2049 │ └── 2049.c │ ├── 2132 │ └── 2132.c │ ├── 2150 │ └── 2150.c │ ├── 2356 │ └── 2356.c │ ├── 2484 │ └── 2484.c │ ├── 2651 │ └── 2651.c │ ├── 2678 │ └── 2678.c │ ├── 2691 │ └── 2691.c │ ├── 2714 │ └── 2714.c │ ├── 3038 │ └── 3038.c │ └── 3088 │ └── 3088.c └── Python ├── Iniciante ├── 1156.py ├── 1000.py ├── 1001.py ├── 3157.py ├── 1016.py ├── 2581.py ├── 1004.py ├── 1059.py ├── 3091.py ├── 1003.py ├── 1114.py ├── 3055.py ├── 1017.py ├── 3146.py ├── 1173.py ├── 1177.py ├── 1142.py ├── 1011.py ├── 2587.py ├── 2861.py ├── 1014.py ├── 1052.py ├── 2146.py ├── 1759.py ├── 1075.py ├── 1002.py ├── 1155.py ├── 1589.py ├── 1930.py ├── 1174.py ├── 2791.py ├── 1013.py ├── 1143.py ├── 3046.py ├── 1963.py ├── 2950.py ├── 1007.py ├── 1019.py ├── 1035.py ├── 1044.py ├── 2235.py ├── 1015.py ├── 2862.py ├── 1080.py ├── 1133.py ├── 1157.py ├── 1924.py ├── 1008.py ├── 1172.py ├── 2161.py ├── 2166.py ├── 2344.py ├── 2483.py ├── 2787.py ├── 1097.py ├── 2879.py ├── 1070.py ├── 1005.py ├── 3047.py ├── 1095.py ├── 3145.py ├── 1096.py ├── 3209.py ├── 2987.py ├── 3147.py ├── 1144.py ├── 1020.py ├── 2780.py ├── 1009.py ├── 1006.py ├── 1117.py ├── 2702.py ├── 2061.py ├── 2159.py ├── 2748.py ├── 1113.py ├── 2172.py ├── 1042.py ├── 2786.py ├── 1079.py ├── 1078.py ├── 2164.py ├── 1043.py ├── 1037.py ├── 1067.py ├── 1957.py ├── 2147.py ├── 2747.py ├── 1132.py ├── 1866.py ├── 1060.py ├── 2234.py ├── 1116.py ├── 1865.py ├── 1041.py ├── 1933.py ├── 2176.py ├── 1564.py ├── 1012.py ├── 2753.py ├── 1065.py ├── 1134.py ├── 2763.py ├── 1050.py ├── 1073.py ├── 1072.py ├── 2717.py ├── 2167.py ├── 1176.py ├── 2756.py ├── 1010.py ├── 1178.py ├── 3170.py ├── 1018.py ├── 1164.py ├── 1036.py ├── 1858.py ├── 1871.py ├── 2006.py ├── 1153.py ├── 1038.py ├── 1115.py ├── 1158.py ├── 1159.py ├── 2896.py ├── 1837.py └── 1046.py └── Strings ├── 1168.py ├── 1278.py ├── 1272.py ├── 2690.py ├── 2866.py ├── 2150.py ├── 1257.py ├── 3141.py ├── 1248.py ├── 2591.py ├── 1586.py ├── 2880.py ├── 2691.py └── 2137.py /C/Iniciante/1190/matriz.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/petbccufscar/beecrowd/HEAD/C/Iniciante/1190/matriz.png -------------------------------------------------------------------------------- /Python/Iniciante/1156.py: -------------------------------------------------------------------------------- 1 | soma = 0 2 | 3 | for i in range(0, 20): 4 | soma += (2 * i + 1) / (2 ** i) 5 | print("{:.2f}".format(soma)) -------------------------------------------------------------------------------- /Python/Iniciante/1000.py: -------------------------------------------------------------------------------- 1 | # Problema 1000 - Beecrowd - Iniciante - Nível 5 2 | 3 | # Imprime a mensagem inteira 4 | print("Hello World!") 5 | -------------------------------------------------------------------------------- /C/Iniciante/1958/1958.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | double X; 5 | scanf("%lf",&X); 6 | 7 | printf("%+.4E\n",X); 8 | 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /C/Iniciante/1001/1001.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int A, B, X; 5 | scanf("%d %d",&A, &B); 6 | X = A + B; 7 | printf("X = %d\n",X); 8 | } 9 | -------------------------------------------------------------------------------- /C/Iniciante/1059/1059.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int par; 5 | for (par=2; par <= 100; par = par+2){ 6 | printf("%d\n", par); 7 | } 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /C/Iniciante/2762/2762.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int X, Y; 5 | 6 | scanf("%d.%d", &X, &Y); 7 | 8 | printf("%d.%d\n", Y, X); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /C/Iniciante/2159/2159.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | double n; 6 | scanf("%lf", &n); 7 | printf("%.1lf %.1lf\n", n/log(n), (1.25506)*(n/log(n))); 8 | return 0; 9 | } -------------------------------------------------------------------------------- /C/Iniciante/2753/2753.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | int i; 6 | 7 | for(i=97; i <= 122 ; i++) 8 | { 9 | printf("%d e %c\n", i, i); 10 | } 11 | 12 | return 0; 13 | } -------------------------------------------------------------------------------- /Python/Iniciante/1001.py: -------------------------------------------------------------------------------- 1 | # Problema 1001 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Basta ler os valores 4 | a = int(input()) 5 | b = int(input()) 6 | 7 | # E printar a soma 8 | print(f'X = {a + b}') -------------------------------------------------------------------------------- /Python/Iniciante/3157.py: -------------------------------------------------------------------------------- 1 | # Problema 3157 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lendo a falácia na entrada 4 | S = input() 5 | 6 | # Imprimindo a verdade 7 | print(f'Nao se refuta ciencia com opiniao') -------------------------------------------------------------------------------- /C/Iniciante/1016/1016.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int dist; 6 | 7 | scanf("%d", &dist); 8 | 9 | printf("%d minutos\n", dist*2); 10 | 11 | return (0); 12 | } 13 | -------------------------------------------------------------------------------- /Python/Iniciante/1016.py: -------------------------------------------------------------------------------- 1 | # Problema 1016 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê o valor distância, multiplica por 2 e guarda 4 | minutos = 2 * int(input()) 5 | 6 | # Imprime na tela 7 | print(f'{minutos} minutos') -------------------------------------------------------------------------------- /Python/Iniciante/2581.py: -------------------------------------------------------------------------------- 1 | # Problema 2581 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Basta ler o número de perguntas 4 | N = int(input()) 5 | 6 | # E printar N vezes a resposta de Toorg 7 | print('I am Toorg!\n'*N, end='') -------------------------------------------------------------------------------- /Python/Iniciante/1004.py: -------------------------------------------------------------------------------- 1 | # Problema 1004 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura dos dados como inteiros 4 | a = int(input()) 5 | b = int(input()) 6 | 7 | # Impressão do resultado 8 | print(f'PROD = {a*b}') 9 | -------------------------------------------------------------------------------- /C/Iniciante/1007/1007.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | int A, B, C, D, X; 6 | scanf("%d %d %d %d",&A, &B, &C, &D); 7 | X = (A * B - C * D); 8 | printf("DIFERENCA = %d\n ",X); 9 | 10 | return 0; 11 | } -------------------------------------------------------------------------------- /C/Iniciante/3076/3076.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | double ano; 6 | 7 | while (~scanf("%lf", &ano)){ 8 | printf("%.lf\n", ceil(ano / 100.0)); 9 | } 10 | 11 | return 0; 12 | } -------------------------------------------------------------------------------- /C/Iniciante/3091/3091.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int dividendo, divisor, resto; 5 | scanf("%d %d", ÷ndo, &divisor); 6 | resto = dividendo % divisor; 7 | printf("%d\n", resto); 8 | return 0; 9 | } -------------------------------------------------------------------------------- /Python/Iniciante/1059.py: -------------------------------------------------------------------------------- 1 | # Problema 1059 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Laço de repetição com i iniciando em 2 até 100 4 | # Incrementando de 2 em 2 5 | for i in range(2, 101, 2): 6 | # Saída de dados 7 | print(i) 8 | 9 | -------------------------------------------------------------------------------- /C/Iniciante/2234/2234.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int H, P; 5 | float media; 6 | 7 | scanf("%d %d",&H, &P); 8 | 9 | media = (float) H/P; 10 | 11 | printf("%.2f\n",media); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /C/Iniciante/1067/1067.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int X, contador; 5 | scanf("%d",&X); 6 | 7 | for(contador = 1; contador<=X; contador++) 8 | if(contador%2!=0) 9 | printf("%d\n",contador); 10 | 11 | return 0; 12 | } -------------------------------------------------------------------------------- /C/Iniciante/1095/1095.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int I=1; 5 | int J=60; 6 | 7 | while(J>=0){ 8 | printf("I=%d J=%d\n",I,J); 9 | I = I + 3; 10 | J = J - 5; 11 | } 12 | 13 | return 0; 14 | 15 | } 16 | -------------------------------------------------------------------------------- /C/Iniciante/2987/2987.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int numero; 5 | char letra; 6 | scanf("%c",&letra); 7 | numero = letra; 8 | numero = numero - 64; 9 | printf("%d\n",numero); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /Python/Iniciante/3091.py: -------------------------------------------------------------------------------- 1 | # Problema 3091 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicialmente, recebemos dois valores 4 | valorA = int(input()) 5 | valorB = int(input()) 6 | 7 | # O resto da divisão se dá pelo operador % 8 | print(valorA % valorB) -------------------------------------------------------------------------------- /C/Iniciante/1014/1014.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int km; 5 | float combustivel, km_l; 6 | scanf("%d %f",&km,&combustivel); 7 | km_l = km / combustivel; 8 | printf("%.3f km/l\n",km_l); 9 | 10 | return 0; 11 | } -------------------------------------------------------------------------------- /Python/Iniciante/1003.py: -------------------------------------------------------------------------------- 1 | # Problema 1003 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura dos valores 4 | A = int(input()) 5 | B = int(input()) 6 | 7 | # Efetuando a soma 8 | SOMA = A + B 9 | 10 | # Saída de dados 11 | print(f'SOMA = {SOMA}') 12 | -------------------------------------------------------------------------------- /C/Iniciante/1003/1003.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int A, B, SOMA; 6 | 7 | scanf("%d", &A); 8 | scanf("%d", &B); 9 | 10 | SOMA = A + B; 11 | 12 | printf("SOMA = %d\n", SOMA); 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /C/Iniciante/1006/1006.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | double a, b, c, media; 6 | scanf("%lf%lf%lf", &a, &b, &c); 7 | media = (2*a + 3*b + 5*c)/10; 8 | printf("MEDIA = %.1lf\n", media); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /C/Iniciante/2483/2483.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int i, indice; 5 | scanf("%d", &indice); 6 | 7 | printf("Feliz nat"); 8 | for(i = 0; i < indice; i++){ 9 | printf("a"); 10 | } 11 | printf("l!\n"); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /C/Iniciante/3046/3046.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int duplo_N, pecas_existentes; 5 | scanf("%d", &duplo_N); 6 | pecas_existentes = (((duplo_N + 1) * (duplo_N + 2)) / 2); 7 | printf("%d\n", pecas_existentes); 8 | return 0; 9 | } -------------------------------------------------------------------------------- /C/Iniciante/3055/3055.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int Nota_A, Nota_B, Media; 6 | 7 | scanf("%d %d",&Nota_A,&Media); 8 | 9 | Nota_B = 2*Media - Nota_A; 10 | 11 | printf("%d\n",Nota_B); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /Python/Iniciante/1114.py: -------------------------------------------------------------------------------- 1 | # Problema 1114 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Loop lendo a entrada até ser igual a senha 4 | while input() != "2002": 5 | print("Senha Invalida") 6 | # Se chegou aqui, então a senha está certa 7 | print("Acesso Permitido") -------------------------------------------------------------------------------- /C/Iniciante/1005/1005.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | float A, B; 8 | scanf("%f%f", &A, &B); 9 | 10 | printf("MEDIA = %.5f\n", ((A*3.5)+(B*7.5))/11); 11 | 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /C/Iniciante/1004/1004.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int A, B, PROD; 5 | 6 | scanf("%d", &A); 7 | scanf("%d", &B); 8 | 9 | PROD = A * B; 10 | 11 | printf("PROD = %d\n",PROD); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /C/Iniciante/1073/1073.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int num, cont; 6 | scanf("%d", &num); 7 | for (cont = 2; cont <= num; cont += 2) 8 | { 9 | printf("%d^2 = %d\n", cont, (cont * cont)); 10 | } 11 | return 0; 12 | } -------------------------------------------------------------------------------- /C/Iniciante/1157/1157.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int N, i; 5 | 6 | 7 | scanf("%d",&N); 8 | for(i = 1; i <= N; i++){ 9 | if(N%i == 0){ 10 | printf("%d\n",i); 11 | } 12 | } 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /C/Iniciante/2146/2146.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | 7 | int senha; 8 | 9 | while(scanf("%d", &senha) != EOF){ 10 | 11 | printf("%d\n", (senha-1)); 12 | } 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /C/Iniciante/1002/1002.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main(){ 5 | 6 | double area, raio, pi; 7 | 8 | pi = 3.14159; 9 | 10 | scanf("%lf",&raio); 11 | area = raio*raio * pi; 12 | printf("A=%.4lf\n",area); 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /C/Iniciante/1153/1153.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int i, x, N; 6 | 7 | scanf("%d", &N); 8 | 9 | x = N; 10 | for (i=1;i 2 | 3 | int main() { 4 | 5 | double soma = 0, n = 1; 6 | 7 | while (n <= 100) { 8 | 9 | soma += 1/n; 10 | n++; 11 | } 12 | 13 | printf("%.2f\n", soma); 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /C/Iniciante/2968/2968.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int v, p, i; 5 | scanf("%d %d", &v, &p); 6 | 7 | for (i = 1; i < 10; ++i){ 8 | printf("%d%c", (i*v*p)%10 ? ((i*v*p)/10)+1 : (i*v*p)/10, i<9 ? ' ' : '\n'); 9 | } 10 | 11 | return 0; 12 | } -------------------------------------------------------------------------------- /C/Iniciante/1070/1070.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int contador,X; 5 | scanf("%d",&X); 6 | 7 | contador = 0; 8 | while (contador<6){ 9 | if(X%2!=0){ 10 | printf("%d\n",X); 11 | contador++; 12 | } 13 | X++; 14 | } 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /C/Iniciante/2763/2763.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int X, Y, Z, D; 5 | 6 | scanf("%d.%d.%d-%d", &X, &Y, &Z, &D); 7 | 8 | printf("%03d\n",X); 9 | printf("%03d\n",Y); 10 | printf("%03d\n",Z); 11 | printf("%02d\n",D); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /Python/Iniciante/3055.py: -------------------------------------------------------------------------------- 1 | # Problema 3055 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicialmente, recebemos os valores da provaA e média 4 | provaA = int(input()) 5 | media = int(input()) 6 | 7 | # O resultado da provaB é igual (2 * media) - provaA 8 | print((2 * media) - provaA) -------------------------------------------------------------------------------- /C/Iniciante/2755/2755.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() 5 | { 6 | 7 | printf("\"Ro'b'er to\\/\"\n"); 8 | printf("(._.) ( l: ) ( .-. ) ( :l ) (._.)\n"); 9 | printf("(^_-) (-_-) (-_^)\n"); 10 | printf("(\"_\") ('.')\n"); 11 | 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /C/Iniciante/2766/2766.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int i; 5 | char palavra[30]; 6 | 7 | for (i = 1; i <= 10; i++){ 8 | scanf("%s", palavra); 9 | 10 | if (i == 3 || i == 7 || i == 9) 11 | printf("%s\n", palavra); 12 | } 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /Python/Iniciante/1017.py: -------------------------------------------------------------------------------- 1 | # Problema 1017 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê as entradas e as armazena 4 | time = int(input()) 5 | speed = int(input()) 6 | 7 | # Imprime na tela a quantidade de litros 8 | # Dado a fórmula (Km/h * h) / Km/L 9 | print(f'{((time*speed)/12):.3f}') -------------------------------------------------------------------------------- /Python/Iniciante/3146.py: -------------------------------------------------------------------------------- 1 | # Problema 3146 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do Raio(R) 4 | R = float(input()) 5 | 6 | # Cálculo do comprimento do anel(C) 7 | C = 2*3.14*R 8 | 9 | # Imprimindo o resultado com duas casas decimais após a vírgula 10 | print(f'{C:.2f}') -------------------------------------------------------------------------------- /C/Iniciante/1011/1011.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | double raio; 6 | scanf("%lf", &raio); 7 | 8 | double volume = (4.0/3) * 3.14159 * pow(raio, 3); 9 | 10 | printf("VOLUME = %.3lf\n", volume); 11 | 12 | return 0; 13 | } -------------------------------------------------------------------------------- /C/Iniciante/1075/1075.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | int cont, N; 7 | 8 | scanf("%d", &N); 9 | 10 | for(cont=1; cont<=10000; cont++){ 11 | if(cont%N == 2){ 12 | printf("%d\n", cont); 13 | } 14 | } 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /C/Iniciante/1096/1096.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int i = 1, j = 7; 5 | int k ; 6 | 7 | while(i<=9){ 8 | for(k=0;k<3;k++){ 9 | printf("I=%d J=%d\n",i,(j-k)); 10 | } 11 | i += 2; 12 | } 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /C/Iniciante/1930/1930.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int t1, t2, t3, t4, soma; 6 | 7 | scanf("%d%d%d%d", &t1, &t2, &t3, &t4); 8 | 9 | soma = t1 + t2 + t3 + t4 - 3; 10 | 11 | printf("%d\n", soma); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /C/Iniciante/2160/2160.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | char entrada[500]; 7 | scanf("%[^\n]", entrada); 8 | 9 | if(strlen(entrada) > 80) 10 | printf("NO\n"); 11 | else 12 | printf("YES\n"); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /C/Iniciante/2510/2510.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int T, i; 6 | char N[26]; 7 | 8 | scanf("%d", &T); 9 | 10 | for(i=0;i 2 | 3 | int main() { 4 | int C; 5 | char entrada[99]; 6 | 7 | scanf("%d\n", &C); 8 | 9 | while (C--) { 10 | fgets(entrada, 99, stdin); 11 | 12 | printf("gzuz\n"); 13 | } 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /C/Iniciante/1589/1589.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int T, R1, R2, i; 6 | 7 | scanf("%d", &T); 8 | 9 | for (i = 1; i <= T; i++) 10 | { 11 | scanf("%d%d", &R1, &R2); 12 | printf("%d\n", R1+R2); 13 | 14 | } 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /C/Iniciante/1963/1963.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | double valorInicial, valorNovo; 6 | 7 | scanf("%lf %lf", &valorInicial, &valorNovo); 8 | 9 | printf("%.2lf%%\n", ( (valorNovo/valorInicial)-1)*100); 10 | 11 | return 0; 12 | } -------------------------------------------------------------------------------- /C/Iniciante/2802/2802.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | long long N, resultado; 7 | scanf("%lli", &N); 8 | 9 | resultado = 1 + (((N - 1) * N) / 2) + ((N * (N - 1)*(N - 2)*(N - 3)) / 24); 10 | printf("%lli\n", resultado); 11 | 12 | return 0; 13 | } -------------------------------------------------------------------------------- /Python/Iniciante/1173.py: -------------------------------------------------------------------------------- 1 | # Problema 1173 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do valor inicial 4 | v = int(input()) 5 | 6 | # Construção da lista 7 | n = [v*2**i for i in range(10)] 8 | 9 | # Impressão dos valores 10 | for i, j in enumerate(n): 11 | print(f'N[{i}] = {j}') -------------------------------------------------------------------------------- /Python/Iniciante/1177.py: -------------------------------------------------------------------------------- 1 | # Problema 1177 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do valor de 't' 4 | t = int(input()) 5 | 6 | # Construção da lista 7 | n = [i%t for i in range(1000)] 8 | 9 | # Impressão dos valores 10 | for i, j in enumerate(n): 11 | print(f'N[{i}] = {j}') -------------------------------------------------------------------------------- /C/Iniciante/3084/3084.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int angulo_horas, angulo_minutos; 5 | 6 | while(scanf("%d %d", &angulo_horas, &angulo_minutos) != EOF) 7 | printf("%02d:%02d\n", (angulo_horas/30), (angulo_minutos/6)); 8 | 9 | return 0; 10 | } -------------------------------------------------------------------------------- /Python/Iniciante/1142.py: -------------------------------------------------------------------------------- 1 | # Problema 1142 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Declaração de variáveis 4 | aux = 1 5 | 6 | # Entrada de dados 7 | num_linhas = int(input()) 8 | 9 | # Saída de dados 10 | for i in range(num_linhas): 11 | print(f"{aux} {aux+1} {aux+2} PUM") 12 | aux +=4 -------------------------------------------------------------------------------- /C/Iniciante/1173/1173.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int n[10], i, v; 6 | 7 | scanf("%d", &v); 8 | 9 | for(i=0; i<=9; i++) 10 | { 11 | n[i]=v; 12 | 13 | printf("N[%d] = %d\n",i,v); 14 | 15 | v=v*2; 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /C/Iniciante/1959/1959.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | int nroLados; 6 | long long int tamLados, perimetro; 7 | scanf("%d %lld", &nroLados, &tamLados); 8 | 9 | perimetro = nroLados * tamLados; 10 | 11 | printf("%lld\n", perimetro); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /C/Iniciante/2880/2880.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () 4 | { 5 | 6 | int distancia; 7 | 8 | scanf("%d", &distancia); 9 | 10 | if (distancia <= 800) 11 | printf("1\n"); 12 | else if (distancia <= 1400) 13 | printf("2\n"); 14 | else 15 | printf("3\n"); 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /C/Iniciante/1097/1097.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int i = 1, j = 7; 5 | int k ; 6 | 7 | while(i<=9){ 8 | for(k=0;k<3;k++){ 9 | printf("I=%d J=%d\n",i,(j-k)); 10 | } 11 | i += 2; 12 | j += 2; 13 | } 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /C/Iniciante/1866/1866.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int C, N, contagem = 0; 5 | 6 | scanf("%d", &C); 7 | 8 | while (contagem < C) { 9 | scanf("%d", &N); 10 | 11 | if (N % 2 == 0) printf("0\n"); 12 | else printf("1\n"); 13 | 14 | contagem++; 15 | } 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /C/Iniciante/2165/2165.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | char T[500]; 7 | 8 | fgets(T, sizeof(T), stdin); 9 | 10 | if(strlen(T)<=140) 11 | printf("TWEET\n"); 12 | 13 | else 14 | printf("MUTE\n"); 15 | 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /C/Iniciante/2765/2765.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char primeira[100]; 6 | char segunda[100]; 7 | 8 | scanf("%[^,],%[^\n]", &primeira, &segunda); 9 | 10 | printf("%s\n", primeira); 11 | printf("%s\n", segunda); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /Python/Iniciante/1011.py: -------------------------------------------------------------------------------- 1 | # Problema 1011 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Primeiro lemos o raio 4 | r = float(input()) 5 | 6 | pi = 3.14159 7 | 8 | # Calculamos o volume 9 | volume = 4/3 * pi * r**3 10 | 11 | # E printamos o volume, com três casas decimais 12 | print(f'VOLUME = {volume:.3f}') -------------------------------------------------------------------------------- /Python/Iniciante/2587.py: -------------------------------------------------------------------------------- 1 | valores = list(map(int,input().split())) 2 | 3 | print(f'A={valores[0]}, B={valores[1]}, C={valores[2]}') 4 | 5 | soma = valores[0] + valores[1] 6 | 7 | if soma > valores[2]: 8 | print(f'A soma ({soma}) é maior que C({valores[2]})') 9 | else: 10 | print('A soma é menor') 11 | -------------------------------------------------------------------------------- /Python/Iniciante/2861.py: -------------------------------------------------------------------------------- 1 | # Problema 2861 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê quantas perguntas serão 4 | n = int(input()) 5 | 6 | for i in range(n): 7 | # Ignora a pergunta da professora 8 | input() 9 | # Imprime a palavra mágica imediatamente após a pergunta 10 | print('gzuz') -------------------------------------------------------------------------------- /C/Iniciante/1019/1019.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int duracao, h, m, s; 6 | 7 | scanf ("%d", &duracao); 8 | 9 | h = duracao/3600; 10 | m = (duracao - h*3600)/60; 11 | s = ((duracao - h*3600) - m*60); 12 | 13 | printf ("%d:%d:%d\n", h, m, s); 14 | 15 | return 0; 16 | 17 | } 18 | -------------------------------------------------------------------------------- /C/Iniciante/2057/2057.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int saida, voo, fuso, chegada; 5 | 6 | scanf("%d %d %d", &saida, &voo, &fuso); 7 | 8 | if(saida == 0) 9 | saida = 24; 10 | 11 | chegada = ((saida + voo + fuso) % 24); 12 | 13 | printf("%d\n", chegada); 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /Python/Iniciante/1014.py: -------------------------------------------------------------------------------- 1 | # Problema 1014 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lendo o combustível consumido 4 | distancia = int(input()) 5 | 6 | # Lendo a distância percorrida 7 | combustivel = float(input()) 8 | 9 | # Imprimindo a saída formatada 10 | print(f'{distancia/combustivel:.3f} km/l') 11 | -------------------------------------------------------------------------------- /C/Iniciante/1013/1013.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | int a,b,c, maior; 6 | scanf("%d %d %d",&a,&b,&c); 7 | 8 | maior = (a+b+abs(a-b))/2; 9 | maior = (maior+c+abs(maior-c))/2; 10 | 11 | printf("%d eh o maior\n",maior); 12 | 13 | return 0; 14 | 15 | } -------------------------------------------------------------------------------- /C/Iniciante/1142/1142.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N; 5 | int i; 6 | int numero = 1 ; 7 | scanf("%d",&N); 8 | 9 | for(i = 1; i <= N; i++) { 10 | printf("%d %d %d PUM\n", numero, numero + 1, numero + 2); 11 | numero = numero + 4; 12 | } 13 | 14 | return 0; 15 | 16 | } 17 | -------------------------------------------------------------------------------- /C/Iniciante/1759/1759.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int N, i; 6 | 7 | scanf("%d", &N); 8 | 9 | for (i = 1; i <= N; i++) 10 | { 11 | if(i==N) 12 | printf("Ho!\n"); 13 | else 14 | printf("Ho "); 15 | 16 | } 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/1924/1924.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int n, i; 6 | char S[100]; 7 | 8 | scanf("%d", &n); 9 | 10 | for(i=0;i 2 | 3 | int main() 4 | { 5 | 6 | int N, A, B; 7 | scanf("%d", &N); 8 | scanf("%d %d", &A, &B); 9 | 10 | if (N < A + B) 11 | printf("Deixa para amanha!\n"); 12 | else 13 | printf("Deixa para amanha!\n"); 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /C/Iniciante/2764/2764.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int dia, mes, ano; 5 | 6 | scanf("%d/%d/%d", &dia, &mes, &ano); 7 | 8 | printf("%02d/%02d/%02d\n", mes, dia, ano); 9 | printf("%02d/%02d/%02d\n", ano, mes, dia); 10 | printf("%02d-%02d-%02d\n", dia, mes, ano); 11 | 12 | return 0; 13 | } -------------------------------------------------------------------------------- /Python/Iniciante/1052.py: -------------------------------------------------------------------------------- 1 | # Problema 1052 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Importa o módulo de calendário 4 | import calendar 5 | 6 | # Recebe o número do mês na entrada padrão 7 | mes = int(input()) 8 | 9 | # Imprime o mês respectivo de acordo com número informado 10 | print(calendar.month_name[mes]) 11 | -------------------------------------------------------------------------------- /C/Iniciante/1078/1078.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int N, cont, result; 6 | 7 | scanf("%d", &N); 8 | 9 | for(cont=1; cont<=10; cont++) 10 | { 11 | result = cont*N; 12 | printf("%d x %d = %d\n", cont, N, result); 13 | } 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /C/Iniciante/1864/1864.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char str[34] = "LIFE IS NOT A PROBLEM TO BE SOLVED"; 6 | int n, i; 7 | 8 | scanf("%d",&n); 9 | 10 | for(i=0;i 2 | 3 | int main(){ 4 | int i, copo, feijao_pos; 5 | 6 | for(i = 0; i < 4; i++){ 7 | scanf("%d",&copo); 8 | if(copo == 1){ 9 | feijao_pos = i + 1; 10 | } 11 | } 12 | 13 | printf("%d\n",feijao_pos); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /Python/Iniciante/2146.py: -------------------------------------------------------------------------------- 1 | # Problema 2146 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Criando o loop para ler as variáveis até finalizar o arquivo(EOF) 4 | 5 | while True: 6 | try: 7 | # Leitura da variável 'n' 8 | n=int(input()) 9 | 10 | # Printando 'n-1' 11 | print(n-1) 12 | 13 | except EOFError: 14 | break -------------------------------------------------------------------------------- /C/Iniciante/1017/1017.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int tempo, velocidade; 6 | float dist; 7 | 8 | scanf("%d", &tempo); 9 | 10 | scanf("%d", &velocidade); 11 | 12 | dist = tempo*velocidade; 13 | 14 | printf("%.3f \n", dist/12); 15 | 16 | return (0); 17 | } 18 | -------------------------------------------------------------------------------- /C/Iniciante/2761/2761.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int A; 5 | float B; 6 | char C, D[50]; 7 | 8 | scanf("%d %f %c %[^\n]s",&A,&B,&C,D); 9 | 10 | printf("%d%.6f%c%s\n",A,B,C,D); 11 | printf("%d\t%.6f\t%c\t%s\n",A,B,C,D); 12 | printf("%10d%10.6f%10c%10s\n",A,B,C,D); 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /C/Iniciante/2867/2867.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int C, N, M, i; 6 | 7 | scanf("%d", &C); 8 | 9 | for(i = 0; i < C; i++) { 10 | scanf("%d %d", &N, &M); 11 | printf("%.f\n", (floor(M * log10(N))) + 1); 12 | } 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /C/Iniciante/2950/2950.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //dividir a distância entre os dois Palantír’s, pela soma do diâmetro dos mesmos. 4 | 5 | int main(){ 6 | float N, X, Y; 7 | float icm; 8 | 9 | scanf("%f %f %f",&N,&X,&Y); 10 | icm = (N / (X + Y)); 11 | printf("%.2f\n",icm); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /Python/Iniciante/1759.py: -------------------------------------------------------------------------------- 1 | # Problema 1759 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do número de 'Ho' 4 | N = int(input()) 5 | 6 | # Criamos uma lista com N Ho's 7 | hos = ['Ho'] * N 8 | 9 | # Usamos join para intercala-los com espaço 10 | hos = ' '.join(hos) 11 | 12 | # Printamos com ! no fim 13 | print(f"{hos}!") -------------------------------------------------------------------------------- /C/Iniciante/1984/1984.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char numero[10]; 6 | int i; 7 | 8 | scanf("%s", numero); 9 | 10 | for (i = (strlen(numero) - 1); i >= 0; i--) { 11 | printf("%c", numero[i]); 12 | } 13 | 14 | printf("\n"); 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /Python/Iniciante/1075.py: -------------------------------------------------------------------------------- 1 | # Problema 1075 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Entrada do valor inteiro N 4 | n = int(input()) 5 | 6 | # Para que se obtenha resto 2 a partir do número N 7 | # é só começar do 2 e ir somando o valor N até que 8 | # o valor seja maior que 10000. 9 | for i in range(2,10001,n): 10 | print(i) -------------------------------------------------------------------------------- /C/Iniciante/1178/1178.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | double X, N[100]; 5 | int i; 6 | 7 | scanf("%lf",&X); 8 | 9 | N[0] = X; 10 | printf("N[0] = %.4lf\n",N[0]); 11 | 12 | for(i=1;i<100;i++){ 13 | N[i] = X/2; 14 | printf("N[%d] = %.4lf\n",i,N[i]); 15 | X = X/2; 16 | } 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /C/Iniciante/1564/1564.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int N; 6 | while (scanf("%d", &N)!=EOF) 7 | { 8 | if(N==0){ 9 | printf("vai ter copa!\n"); 10 | } 11 | else 12 | { 13 | printf("vai ter duas!\n"); 14 | } 15 | 16 | } 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/2006/2006.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int cha, degustador, acertos, i; 5 | 6 | acertos = 0; 7 | 8 | scanf("%d", &cha); 9 | 10 | for(i=0; i<5; i++){ 11 | scanf("%d", °ustador); 12 | 13 | if(cha == degustador) 14 | acertos++; 15 | } 16 | printf("%d\n", acertos); 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/2879/2879.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int jogos, carro, ganhou; 6 | 7 | ganhou = 0; 8 | 9 | scanf("%d", &jogos); 10 | while (jogos--) 11 | { 12 | scanf("%d", &carro); 13 | if (carro != 1) 14 | ++ganhou; 15 | } 16 | 17 | printf("%d\n", ganhou); 18 | 19 | return 0; 20 | 21 | } -------------------------------------------------------------------------------- /Python/Iniciante/1002.py: -------------------------------------------------------------------------------- 1 | # Problema 1002 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê o valor do raio pela entrada padrão 4 | r = float(input()) 5 | 6 | # Calcula o valor conforme a fórmula fornecida 7 | area = 3.14159*(r**2) 8 | 9 | # Imprime o valor na saída padrão com arredondamento de 4 casas decimais 10 | print(f'A={area:.4f}') -------------------------------------------------------------------------------- /C/Iniciante/2581/2581.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int N, i; 6 | char *mensagem = (char*) malloc(sizeof(char)); 7 | 8 | scanf("%d",&N); 9 | 10 | for(i=1; i<=N; i++){ 11 | scanf("%s",mensagem); 12 | printf("I am Toorg!\n"); 13 | fflush(stdin); 14 | } 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /Python/Iniciante/1155.py: -------------------------------------------------------------------------------- 1 | # Problema 1155 - Beecrowd - Iniciante - Nível 2 2 | 3 | # A fórmula em Python pode ser escrita da seguinte forma: 4 | # Onde pra cada elemento do range de 1 até 100, é feita uma soma 5 | # de 1 sobre o elemento. 6 | resultado = sum(1 / x for x in range(1, 101)) 7 | 8 | # Impressão do resultado 9 | print(f'{resultado:.2f}') -------------------------------------------------------------------------------- /Python/Iniciante/1589.py: -------------------------------------------------------------------------------- 1 | # Problema 1589 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do número de testes 4 | T = int(input()) 5 | 6 | # Aqui usamos o _ pois o valor não tem importância 7 | for _ in range(T): 8 | # Então lemos os raios 9 | R1, R2 = map(int, input().split(' ')) 10 | 11 | # E printamos a soma 12 | print(R1 + R2) -------------------------------------------------------------------------------- /Python/Iniciante/1930.py: -------------------------------------------------------------------------------- 1 | # Problema 1930 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura das quantidade de tomadas de todas as réguas disponíveis 4 | tomadas = list(map(int, input().split(' '))) 5 | 6 | # Como sempre são 4 réguas, e estão ligadas uma na outra, 7 | # 3 tomadas serão utilizadas nessas ligações 8 | print(f'{sum(tomadas) - 3}') -------------------------------------------------------------------------------- /C/Iniciante/1143/1143.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int N; 6 | int i; 7 | int num1; 8 | int num2; 9 | scanf("%d",&N); 10 | 11 | for(i = 1; i <= N; i++) { 12 | num1 = pow(i,2); 13 | num2 = pow(i,3); 14 | printf("%d %d %d\n", i, num1, num2); 15 | } 16 | return 0; 17 | 18 | } 19 | -------------------------------------------------------------------------------- /C/Iniciante/1146/1146.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int X, i; 6 | 7 | scanf("%d", &X); 8 | 9 | while (X != 0) { 10 | 11 | for(i = 1; i < X; i++) 12 | printf("%d ", i); 13 | 14 | printf("%d\n", X); 15 | 16 | scanf("%d", &X); 17 | } 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /C/Iniciante/1177/1177.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int N[1000]; 6 | int T, i, aux; 7 | scanf("%d", &T); 8 | aux = 0; 9 | for (i = 0; i < 1000; i++) 10 | { 11 | printf("N[%d] = %d\n", i, aux); 12 | aux++; 13 | if(aux==T){ 14 | aux=0; 15 | } 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /C/Iniciante/2334/2334.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main (){ 4 | long double qntPatinhos; 5 | 6 | while (1){ 7 | scanf("%LF", &qntPatinhos); 8 | 9 | if (qntPatinhos == -1) 10 | break; 11 | 12 | if (qntPatinhos == 0) 13 | printf("0\n"); 14 | else 15 | printf("%.LF\n", --qntPatinhos); 16 | } 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/2759/2759.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | char a, b, c; 6 | 7 | scanf("%c %c %c", &a, &b, &c); 8 | 9 | printf("A = %c, B = %c, C = %c\n", a, b, c); 10 | printf("A = %c, B = %c, C = %c\n", b, c, a); 11 | printf("A = %c, B = %c, C = %c\n", c, a, b); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /C/Iniciante/1114/1114.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int senha; 6 | 7 | do { 8 | scanf("%d", &senha); 9 | if (senha == 2002) 10 | printf ("Acesso Permitido\n"); 11 | else 12 | printf ("Senha Invalida\n"); 13 | } while (senha != 2002); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /C/Iniciante/1145/1145.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int X, Y, i; 6 | 7 | scanf("%d %d", &X, &Y); 8 | 9 | for (i = 1; i <= Y; i++) { 10 | printf("%d", i); 11 | 12 | if (i % X == 0) 13 | printf("\n"); 14 | else 15 | printf(" "); 16 | } 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/2172/2172.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int mult; 6 | unsigned long int exp; 7 | 8 | scanf("%d %lu", &mult, &exp); 9 | 10 | while (exp != 0 && mult != 0) { 11 | printf("%lu\n", (exp * mult)); 12 | 13 | scanf("%d %lu", &mult, &exp); 14 | } 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /C/Iniciante/2235/2235.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int A, B, C; 5 | scanf("%d %d %d",&A, &B, &C); 6 | 7 | if(A == B || A == C || B == C) 8 | printf("S\n"); 9 | 10 | else { 11 | if( (A+B == C) || (A+C == B) || (B+C == A)) 12 | printf("S\n"); 13 | else 14 | printf("N\n"); 15 | } 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /Python/Iniciante/1174.py: -------------------------------------------------------------------------------- 1 | # Problema 1174 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Leitura dos 100 números iniciais 4 | A = [] 5 | for i in range(100): 6 | A.append(float(input())) 7 | 8 | # Imprimindo todos os números menores ou iguais a 10 9 | for i in range(100): 10 | if A[i]<=10: 11 | print(f'A[{i}] = {A[i]:.1f}') 12 | 13 | -------------------------------------------------------------------------------- /Python/Iniciante/2791.py: -------------------------------------------------------------------------------- 1 | # Problema 2791 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura das variáveis 4 | c1,c2,c3,c4 = map(int, input().split(' ')) 5 | 6 | # Verificando os casos e imprimindo a saída 7 | if(c1==1): 8 | print(1) 9 | 10 | elif(c2==1): 11 | print(2) 12 | 13 | elif(c3==1): 14 | print(3) 15 | 16 | elif(c4==1): 17 | print(4) -------------------------------------------------------------------------------- /C/Iniciante/1008/1008.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int numero, horasTrabalhadas; 5 | float valorPorHora; 6 | 7 | scanf("%d %d %f", &numero, &horasTrabalhadas, &valorPorHora); 8 | 9 | printf("NUMBER = %d\n", numero); 10 | printf("SALARY = U$ %.2f\n", horasTrabalhadas*valorPorHora); 11 | 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /C/Iniciante/1009/1009.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | char nome[]=""; 7 | float salario, vendas, salariofinal; 8 | 9 | scanf("%s %f %f", nome, &salario, &vendas); 10 | 11 | salariofinal = salario + (vendas * 0.15f); 12 | 13 | printf("TOTAL = R$ %.2f\n", salariofinal); 14 | 15 | return (0); 16 | } -------------------------------------------------------------------------------- /C/Iniciante/1933/1933.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int A, B, terceiraCarta; 5 | scanf("%d %d",&A,&B); 6 | 7 | if(A == B) 8 | terceiraCarta = A; 9 | 10 | else{ 11 | if(A>B) 12 | terceiraCarta = A; 13 | if(B>A) 14 | terceiraCarta = B; 15 | } 16 | 17 | printf("%d\n",terceiraCarta); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /C/Iniciante/2161/2161.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int nro, i; 6 | float raiz = 0.0; 7 | 8 | scanf("%d", &nro); 9 | 10 | for (i = 0; i < nro; i++) 11 | { 12 | raiz += 6.0; 13 | raiz = 1.0 / raiz; 14 | } 15 | raiz += 3.0; 16 | 17 | printf("%.10f\n", raiz); 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Python/Iniciante/1013.py: -------------------------------------------------------------------------------- 1 | # Problema 1013 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Vamos definir a função que retorna o maior valor 4 | def maior(a, b): 5 | return int((a + b + abs(a - b)) / 2) 6 | 7 | # Então lemos os três valores 8 | a, b, c = map(int, input().split()) 9 | 10 | # E printamos o maior 11 | print(f'{maior(maior(a, b), c)} eh o maior') -------------------------------------------------------------------------------- /Python/Iniciante/1143.py: -------------------------------------------------------------------------------- 1 | # Problema 1143 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê o valor fornecido pela entrada padrão 4 | valor = int(input()) 5 | 6 | # X assumirá todos os valores de 0 até o VALOR - 1 7 | # em seguida, imprime o valor de X, seguido por X ao quadrado e X ao cubo 8 | for x in range(valor): 9 | print(f'{x+1} {(x+1)**2} {(x+1)**3}') -------------------------------------------------------------------------------- /Python/Iniciante/3046.py: -------------------------------------------------------------------------------- 1 | # Problema 3046 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Recebendo qual é o maior valor em um quadrado em uma peça 4 | n = int(input()) 5 | 6 | # Calculando o número máximo de peças no jogo usando a fórmula dada 7 | totalPcs = int(((n+1)*(n+2))/2) 8 | 9 | # Apresentando para o usuário o número total de peças 10 | print(totalPcs) -------------------------------------------------------------------------------- /C/Iniciante/1172/1172.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int X[10], i; 6 | 7 | for (i = 0; i < 10; i++){ 8 | scanf("%d", &X[i]); 9 | } 10 | 11 | for (i=0 ; i<10; i++){ 12 | if (X[i]<=0) 13 | X[i] = 1; 14 | 15 | printf("X[%d] = %d\n", i, X[i]); 16 | } 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/1174/1174.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | double A[100]; 7 | int i; 8 | 9 | for(i=0; i<100; i++) 10 | scanf("%lf", &A[i]); 11 | 12 | for(i=0; i<100; i++) 13 | { 14 | 15 | if(A[i]<=10.0) 16 | printf("A[%d] = %.1lf\n",i, A[i]); 17 | 18 | } 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /Python/Iniciante/1963.py: -------------------------------------------------------------------------------- 1 | # Problema 1963 - Beecrowd - Iniciante - Nível 2 2 | 3 | #Recebe a entrada e já a divide em 2 partes para serem armazenadas 4 | num1, num2 = map(float, input('').split()) 5 | 6 | #Calcula a porcentagem de aumento de preço do novo ingresso 7 | x = ((num2 * 100)/num1) - 100 8 | 9 | #Imprime a porcentagem obtida 10 | print(f'{x:.2f}%') -------------------------------------------------------------------------------- /Python/Iniciante/2950.py: -------------------------------------------------------------------------------- 1 | # Problema 2950 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicializa as variáveis e atribui 4 | # os valores da distância entre os Palantír's 5 | # e os seus respectivos diâmetros 6 | Distancia, Diametro1, Diametro2 = map(int, input().split(' ')) 7 | 8 | # Imprime a ICM 9 | print("{:.2f}".format(Distancia/(Diametro1 + Diametro2))) 10 | -------------------------------------------------------------------------------- /C/Iniciante/1154/1154.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int idade, n = 0; 6 | double soma = 0; 7 | 8 | scanf("%d", &idade); 9 | 10 | while (idade >= 0) { 11 | 12 | soma += idade; 13 | n++; 14 | scanf("%d", &idade); 15 | } 16 | 17 | printf("%.2f\n", soma/n); 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /C/Iniciante/2344/2344.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main (){ 4 | int n; 5 | scanf("%d", &n); 6 | 7 | if (n == 0) 8 | printf("E\n"); 9 | else if (n >= 1 && n <= 35) 10 | printf("D\n"); 11 | else if (n >= 36 && n <= 60) 12 | printf("C\n"); 13 | else if (n >= 61 && n <= 85) 14 | printf("B\n"); 15 | else 16 | printf("A\n"); 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/2756/2756.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | printf(" A\n"); 6 | printf(" B B\n"); 7 | printf(" C C\n"); 8 | printf(" D D\n"); 9 | printf(" E E\n"); 10 | printf(" D D\n"); 11 | printf(" C C\n"); 12 | printf(" B B\n"); 13 | printf(" A\n"); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /Python/Iniciante/1007.py: -------------------------------------------------------------------------------- 1 | # Problema 1007 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Recebe os quatro valores e salva cada um em uma variável 4 | A = int(input()) 5 | B = int(input()) 6 | C = int(input()) 7 | D = int(input()) 8 | 9 | # Imprime na tela o texto "DIFERENCA =" seguido do resultado pedido no exercício 10 | print(f'DIFERENCA = {A * B - C * D}') 11 | -------------------------------------------------------------------------------- /Python/Iniciante/1019.py: -------------------------------------------------------------------------------- 1 | # Problema 1019 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Entrada de dados 4 | segundos = int(input()) 5 | 6 | # Conversao de segundos para horas e minutos 7 | horas = segundos//3600 8 | segundos = segundos%3600 9 | minutos = segundos//60 10 | segundos = segundos%60 11 | 12 | # Saída de dados 13 | print(f'{horas}:{minutos}:{segundos}') 14 | -------------------------------------------------------------------------------- /Python/Iniciante/1035.py: -------------------------------------------------------------------------------- 1 | # Problema 1035 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Vamos ler os valores como inteiros 4 | a, b, c, d = map(int, input().split()) 5 | 6 | # E fazer todas as verificações que o problema pede 7 | if b > c and d > a and (c+d) > (a+b) and c > 0 and d > 0 and a%2==0: 8 | print('Valores nao aceitos') 9 | else: 10 | print('Valores aceitos') -------------------------------------------------------------------------------- /Python/Iniciante/1044.py: -------------------------------------------------------------------------------- 1 | # Problema 1044 - Beeccrowd - Iniciante - Nível 2 2 | 3 | # Recebe os valores na entrada padrão 4 | valorA, valorB = map(float, input().split()) 5 | 6 | # Verifica a divisibilidade para saber se são múltiplos ou não 7 | if valorA%valorB == 0 or valorB%valorA == 0: 8 | print("Sao Multiplos") 9 | else: 10 | print("Nao sao Multiplos") 11 | -------------------------------------------------------------------------------- /Python/Iniciante/2235.py: -------------------------------------------------------------------------------- 1 | # Problema 2235 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura dos dados 4 | a, b, c = map(int, input().split(' ')) 5 | 6 | # Comparações para verificação de resultado 7 | if(a == b or a == c or b == c): 8 | print("S") 9 | else: 10 | if(a + b == c or a + c == b or b + c == a): 11 | print("S") 12 | else: 13 | print("N") 14 | -------------------------------------------------------------------------------- /C/Iniciante/1149/1149.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | 4 | int A, N, i, soma; 5 | 6 | soma = 0; 7 | 8 | scanf("%d %d", &A, &N); 9 | 10 | while (N <= 0) { 11 | scanf("%d", &N); 12 | } 13 | 14 | for (i = 0; i < N; i++) { 15 | soma += (A + i); 16 | } 17 | 18 | printf("%d\n", soma); 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /C/Iniciante/1156/1156.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | 6 | double soma = 0, numerador = 1, n = 2, i = 0; 7 | 8 | while (numerador <= 39) { 9 | 10 | soma += numerador/pow(n, i); 11 | 12 | numerador += 2; 13 | i++; 14 | } 15 | 16 | printf("%.2f\n", soma); 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/1060/1060.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | float valor; 5 | int positivos = 0; 6 | int i; 7 | 8 | for(i = 0; i < 6; i++) { 9 | scanf("%f", &valor); 10 | 11 | if(valor > 0) { 12 | positivos++; 13 | } 14 | } 15 | 16 | printf("%d valores positivos\n", positivos); 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/2003/2003.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | int hora, minuto; 6 | 7 | while(scanf("%d:%d", &hora, &minuto)!=EOF){ 8 | 9 | printf("Atraso maximo: "); 10 | 11 | if(hora<7 || (hora==7 && minuto==0)) 12 | printf("0\n"); 13 | else{ 14 | minuto = ((hora + 1)-8)*60 + minuto; 15 | printf("%d\n", minuto); 16 | } 17 | } 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Python/Iniciante/1015.py: -------------------------------------------------------------------------------- 1 | # Problema 1015 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Adicionando "math" para usar "sqrt" 4 | from math import sqrt 5 | 6 | # Lendo x1 e y1 7 | x1, y1 = map(float, input().split(" ")) 8 | 9 | # Lendo x2 e y2 10 | x2, y2 = map(float, input().split(" ")) 11 | 12 | # Imprimindo a distância 13 | print(f'{(sqrt((x2 - x1)**2 + (y2 - y1)**2)):.4f}') 14 | -------------------------------------------------------------------------------- /C/Iniciante/2862/2862.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int C, N, i; 6 | 7 | scanf("%d", &C); 8 | 9 | for (i = 0; i < C; i++) { 10 | scanf("%d", &N); 11 | 12 | if (N > 8000) { 13 | printf("Mais de 8000!\n"); 14 | } else { 15 | printf("Inseto!\n"); 16 | } 17 | } 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Python/Iniciante/2862.py: -------------------------------------------------------------------------------- 1 | # Problema 2862 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê a quantidade de valores 4 | n = int(input()) 5 | 6 | for i in range(n): 7 | # Lê o número e verifica se é maior que 8000 8 | # Se for maior que 8000, ele imprime "Mais de 8000!" 9 | # Caso contrário, imprimirá "Inseto!" 10 | print('Mais de 8000!' if int(input()) > 8000 else "Inseto!") -------------------------------------------------------------------------------- /C/Iniciante/1044/1044.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | int A,B; 8 | scanf("%d%d", &A, &B); 9 | if (B==0||A==0) 10 | { 11 | return 0; 12 | } 13 | 14 | if (((A%B)==0||(B%A)==0)) 15 | { 16 | printf("Sao Multiplos\n"); 17 | } 18 | else 19 | { 20 | printf("Nao sao Multiplos\n"); 21 | } 22 | return 0; 23 | } -------------------------------------------------------------------------------- /C/Iniciante/1116/1116.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int N, x, y, i; 6 | 7 | scanf("%d", &N); 8 | 9 | for(i=0;i 2 | 3 | 4 | int main() 5 | { 6 | double n, raiz; 7 | 8 | raiz = 0.0; 9 | 10 | scanf("%lf", &n); 11 | 12 | while(n>0) 13 | { 14 | raiz = raiz + 2.0; 15 | raiz = 1/raiz; 16 | n--; 17 | } 18 | 19 | raiz = raiz + 1.0; 20 | 21 | printf("%.10lf\n", raiz); 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /C/Iniciante/2721/2721.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | char *renas[] = {"Rudolph", "Dasher", "Dancer", "Prancer", "Vixen", "Comet", "Cupid", "Donner", "Blitzen"}; 7 | int i, A, soma = 0; 8 | for (i = 0; i < 9; i++) 9 | { 10 | scanf("%d", &A); 11 | soma += A; 12 | } 13 | printf("%s\n", renas[soma % 9]); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /Python/Iniciante/1080.py: -------------------------------------------------------------------------------- 1 | # Problema 1080 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Declaramos a lista vazia 4 | lista = [] 5 | 6 | # Primeiramente, lemos os 100 valores e colocamos na lista 7 | for i in range(100): 8 | lista.append(int(input())) 9 | 10 | # Mostramos o maior valor da lista e logo após, sua posição na lista 11 | print(max(lista)) 12 | print(lista.index(max(lista)) + 1) -------------------------------------------------------------------------------- /Python/Iniciante/1133.py: -------------------------------------------------------------------------------- 1 | # Problema 1135 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Entrada dos valores. 4 | x = int(input()) 5 | y = int(input()) 6 | 7 | # Verificando o número maior. 8 | if x > y: 9 | x, y = y, x 10 | 11 | # Loop para varrer todos os números entre x e y e saída esperada. 12 | for i in range(x + 1, y): 13 | if i % 5 == 2 or i % 5 == 3: 14 | print(i) 15 | -------------------------------------------------------------------------------- /C/Iniciante/1065/1065.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int contPares = 0; 6 | int valor; 7 | 8 | int i ; 9 | for( i = 0; i < 5; i++){ 10 | scanf("%d", &valor); 11 | if( valor%2 == 0){ 12 | contPares++; 13 | } 14 | } 15 | 16 | printf("%d valores pares\n", contPares); 17 | 18 | return (0); 19 | } -------------------------------------------------------------------------------- /C/Iniciante/1071/1071.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int contador, X, Y, aux, soma; 5 | scanf("%d%d",&X,&Y); 6 | 7 | if(X>Y){ 8 | aux=X; 9 | X=Y; 10 | Y=aux; 11 | } 12 | 13 | soma=0; 14 | for(contador=X+1; contador 2 | 3 | int main() { 4 | 5 | int Largura,Comprimento,tipo1,tipo2; 6 | 7 | scanf("%d %d",&Largura,&Comprimento); 8 | 9 | tipo1 = (Largura+Largura-1)*(Comprimento-1)+Largura; 10 | tipo2 = ((Largura-1)*2) + ((Comprimento-1)*2); 11 | 12 | printf("%d\n", tipo1); 13 | printf("%d\n", tipo2); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /C/Iniciante/1144/1144.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int N; 6 | int i; 7 | int num1; 8 | int num2; 9 | scanf("%d",&N); 10 | 11 | for(i = 1; i <= N; i++) { 12 | num1 = pow(i,2); 13 | num2 = pow(i,3); 14 | printf("%d %d %d\n", i, num1, num2); 15 | printf("%d %d %d\n", i, num1 + 1, num2 + 1); 16 | } 17 | return 0; 18 | 19 | } 20 | -------------------------------------------------------------------------------- /C/Iniciante/2544/2544.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | int x; 7 | long long int num; 8 | 9 | while (scanf("%lld", &num)!=EOF) 10 | { 11 | if (num==1) 12 | printf("0\n"); 13 | else{ 14 | x = log2(num); 15 | printf("%d\n", x); 16 | } 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /C/Iniciante/2757/2757.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() 5 | { 6 | int A, B, C; 7 | scanf("%d%d%d", &A, &B, &C); 8 | 9 | printf("A = %d, B = %d, C = %d\n", A, B, C); 10 | printf("A = %10d, B = %10d, C = %10d\n", A, B, C); 11 | printf("A = %010d, B = %010d, C = %010d\n", A, B, C); 12 | printf("A = %-10d, B = %-10d, C = %-10d\n", A, B, C); 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /Python/Iniciante/1157.py: -------------------------------------------------------------------------------- 1 | # Problema 1157 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lendo o valor inteiro 4 | entrada = int(input()) 5 | # Variável auxiliar 6 | i = 1 7 | # Loop para conferir divisores 8 | while i <= entrada: 9 | # Teste de divisor e impressão em caso afirmativo 10 | if(entrada % i == 0): 11 | print(i) 12 | # Incrementando variável de controle do loop 13 | i += 1 14 | -------------------------------------------------------------------------------- /C/Iniciante/2147/2147.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int casos, tam; 6 | char galopeira[10000]; 7 | 8 | scanf("%d", &casos); 9 | 10 | while(casos>0) 11 | { 12 | scanf("%s", galopeira); 13 | 14 | tam = strlen(galopeira); 15 | 16 | printf("%.2lf\n", tam*.01); 17 | 18 | casos--; 19 | } 20 | return 0; 21 | } -------------------------------------------------------------------------------- /Python/Iniciante/1924.py: -------------------------------------------------------------------------------- 1 | # Problema 1924 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura inicial da quantidade de linhas a serem lidas dentro do FOR 4 | 5 | for x in range(int(input())): 6 | # A resposta impressa independe das strings obtidas 7 | tantoFaz = input() 8 | 9 | # Sempre a mesma resposta é impressa, independente das entradas 10 | 11 | print("Ciencia da Computacao") 12 | -------------------------------------------------------------------------------- /C/Iniciante/1113/1113.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int X, Y; 6 | 7 | scanf("%d %d", &X, &Y); 8 | 9 | while(X!=Y){ 10 | if(X>Y){ 11 | printf("Decrescente\n"); 12 | } 13 | else if(X 2 | 3 | int main(){ 4 | double volume, diametro, altura, area, raio; 5 | 6 | while(scanf("%lf%lf", &volume, &diametro)!=EOF){ 7 | raio = diametro/2; 8 | area = 3.14*raio*raio; 9 | altura = volume/area; 10 | 11 | printf("ALTURA = %.2lf\n", altura); 12 | printf("AREA = %.2lf\n", area); 13 | } 14 | return 0; 15 | } -------------------------------------------------------------------------------- /C/Iniciante/2863/2863.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () 4 | { 5 | 6 | int T, i; 7 | float numero, menor; 8 | 9 | while (scanf("%d", &T) != EOF) 10 | { 11 | 12 | menor = 100.0; 13 | for (i = 0; i < T; i++) 14 | { 15 | scanf("%f", &numero); 16 | if (numero < menor) 17 | menor = numero; 18 | 19 | } 20 | 21 | printf("%.2f\n", menor); 22 | 23 | } 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /C/Iniciante/3047/3047.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char **argv) 4 | { 5 | 6 | int M, A, B, X; 7 | 8 | scanf("%d %d %d", &M, &A, &B); 9 | 10 | X = M - A - B; 11 | 12 | if (X > A && X > B) 13 | printf("%d\n", X); 14 | else if (A > B && A > X) 15 | printf("%d\n", A); 16 | else 17 | printf("%d\n", B); 18 | 19 | return 0; 20 | 21 | } -------------------------------------------------------------------------------- /Python/Iniciante/1008.py: -------------------------------------------------------------------------------- 1 | # Problema 1079 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura das variáveis 4 | numero_funcionario = int(input()) 5 | horas_trabalhadas = int(input()) 6 | valor_hora = float(input()) 7 | 8 | # Cálculo do salário 9 | salario = horas_trabalhadas * valor_hora 10 | 11 | # Imprimindo as saídas 12 | print(f'NUMBER = {numero_funcionario}') 13 | print(f'SALARY = U$ {salario:.2f}') 14 | -------------------------------------------------------------------------------- /Python/Iniciante/1172.py: -------------------------------------------------------------------------------- 1 | # Problema 1172 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Definindo a lista 4 | X = [] 5 | # Lendo os valores do vetor 6 | for i in range(10): 7 | X.append(int(input())) 8 | # Conferindo os valores e substituindo nulos e negativos 9 | if(X[i] <= 0): 10 | X[i] = 1 11 | # Imprimindo valores atualizados 12 | for i in range(10): 13 | print(f'X[{i}] = {X[i]}') 14 | 15 | -------------------------------------------------------------------------------- /Python/Iniciante/2161.py: -------------------------------------------------------------------------------- 1 | # Problema 2161 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê a entrada 4 | repeticoes = int(input()) 5 | 6 | # Inicia a variável soma com 0 7 | soma = 0.0 8 | 9 | # Laço de repetição 10 | for i in range(repeticoes): 11 | # calculo da fração 12 | soma = 1.0/(soma+6.0) 13 | 14 | # Acrescenta 3 à fração 15 | soma += 3 16 | 17 | # Imprime o resultado 18 | print(f'{soma:.10f}') -------------------------------------------------------------------------------- /Python/Iniciante/2166.py: -------------------------------------------------------------------------------- 1 | # Problema 2166 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê a entrada 4 | repeticoes = int(input()) 5 | 6 | # Inicia a variável soma com 0 7 | soma = 0.0 8 | 9 | # Laço de repetição 10 | for i in range(repeticoes): 11 | # calculo da fração 12 | soma = 1.0/(soma+2.0) 13 | 14 | # Acrescenta 1 à fração 15 | soma += 1 16 | 17 | # Imprime o resultado 18 | print(f'{soma:.10f}') -------------------------------------------------------------------------------- /Python/Iniciante/2344.py: -------------------------------------------------------------------------------- 1 | # Problema 2344 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lendo a nota 4 | nota = int(input()) 5 | 6 | # Fazendo a conversão da nota 7 | if(nota == 0): 8 | print('E') 9 | elif(nota >= 1 and nota <= 35): 10 | print('D') 11 | elif(nota >= 36 and nota <= 60): 12 | print('C') 13 | elif(nota >= 61 and nota <= 85): 14 | print('B') 15 | else: 16 | print('A') 17 | 18 | 19 | -------------------------------------------------------------------------------- /Python/Iniciante/2483.py: -------------------------------------------------------------------------------- 1 | # Problema 2483 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lendo o índice de felicidade 4 | felicidade = int(input()) 5 | 6 | # Imprimindo o começo da mensagem, sem a quebra de linha 7 | print('Feliz nat', end='') 8 | 9 | # Imprimindo os 'a' de felicidade 10 | for i in range(felicidade): 11 | print('a', end='') 12 | 13 | # Imprimindo o final da mensagem 14 | print('l!') 15 | -------------------------------------------------------------------------------- /Python/Iniciante/2787.py: -------------------------------------------------------------------------------- 1 | # Problema 2787 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura das variáveis de entrada 4 | L = int(input()) 5 | C = int(input()) 6 | 7 | # Verificando os casos baseado nas entradas serem par ou ímpar, e printando o resultado 8 | if(L%2 == 0): 9 | if(C%2 == 0): 10 | print(1) 11 | else: 12 | print(0) 13 | else: 14 | if(C%2 == 0): 15 | print(0) 16 | else: 17 | print(1) 18 | -------------------------------------------------------------------------------- /C/Iniciante/1176/1176.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int T, N, i; 5 | long long int Fib[61]; 6 | 7 | Fib[0] = 0; 8 | Fib[1] = 1; 9 | 10 | for(i = 2; i <= 60; i++) 11 | Fib[i] = Fib[i-1] + Fib[i-2]; 12 | 13 | scanf("%d", &T); 14 | for(i = 1; i<= T; i++){ 15 | scanf("%d", &N); 16 | printf("Fib(%d) = %lld\n", N, Fib[N]); 17 | } 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/2167/2167.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int N, R[100], i; 6 | 7 | scanf("%d", &N); 8 | 9 | for(i=0;i R[i]) { 14 | printf("%d\n", i+1); 15 | return 0; 16 | } 17 | } 18 | printf("0\n"); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /Python/Iniciante/1097.py: -------------------------------------------------------------------------------- 1 | # Problema 1097 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Declaração das variáveis 4 | i=1 5 | j=7 6 | 7 | # Início do primeiro loop 8 | for contador1 in range(5): 9 | # Início do segundo loop 10 | for contador2 in range(3): 11 | # Imprimindo a saída e incrementando a variável 'j' 12 | print(f'I={i} J={j}') 13 | j=j-1 14 | # Incremento as variáveis 'i' e 'j' 15 | i=i+2 16 | j=j+5 -------------------------------------------------------------------------------- /Python/Iniciante/2879.py: -------------------------------------------------------------------------------- 1 | # Problema 2879 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lê a quantidade de valores 4 | n = int(input()) 5 | partidas_perdidas = 0 6 | 7 | for i in range(n): 8 | # Lê o número e verifica se é 1 9 | # Caso for, essa partida não será ganha 10 | if int(input()) == 1: 11 | partidas_perdidas += 1 12 | 13 | # Imprime a quantidade de jogos ganhos 14 | print(n - partidas_perdidas) -------------------------------------------------------------------------------- /C/Iniciante/1015/1015.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | float x1, y1, x2, y2, distX, distY, dist; 7 | 8 | scanf("%f %f", &x1, &y1); 9 | 10 | scanf("%f %f", &x2, &y2); 11 | 12 | distX = x2-x1; 13 | 14 | distY = y2-y1; 15 | 16 | dist = sqrt(pow(distX,2)+pow(distY,2)); 17 | 18 | printf("%.4f\n", dist); 19 | 20 | return (0); 21 | } 22 | -------------------------------------------------------------------------------- /C/Iniciante/1837/1837.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, q, r; 5 | 6 | scanf("%d %d", &a, &b); 7 | 8 | r = a % b; 9 | 10 | if (r < 0) { 11 | if (b > 0) 12 | r = b + r; 13 | else 14 | r = -b + r; 15 | } 16 | 17 | 18 | q = (a - r) / b; 19 | 20 | printf("%d %d\n", q, r); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /Python/Iniciante/1070.py: -------------------------------------------------------------------------------- 1 | # Problema 1070 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do valor de x 4 | x = int(input()) 5 | 6 | # Calculo do menor ímpar maior ou igual à x 7 | # x%2 retorna 1 se x é ímpar 8 | # (x+1)%2 retorna 1 se x é par 9 | # se somamos 1 a um x par, ele se torna ímpar 10 | x += (x+1)%2 11 | 12 | # Loop para imprimir os seis valores 13 | for i in range(6): 14 | print(x) 15 | x += 2 -------------------------------------------------------------------------------- /C/Iniciante/1175/1175.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int N[20], aux,i, j; 5 | 6 | for(i=0; i<20; i++) 7 | scanf("%d",&N[i]); 8 | 9 | j=19; 10 | for(i=0; i<10; i++) 11 | { 12 | aux=N[i]; 13 | N[i]=N[j]; 14 | N[j]=aux; 15 | j--; 16 | } 17 | 18 | for(i=0; i<20; i++) 19 | printf("N[%d] = %d\n",i,N[i]); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /C/Iniciante/2845/2845.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int N, A[10000], maior, i; 6 | 7 | scanf("%d", &N); 8 | 9 | for (i=0;i 2 | #include 3 | 4 | int main() { 5 | 6 | char msg[100]; 7 | int bits, i; 8 | 9 | bits = 0; 10 | 11 | scanf("%s", msg); 12 | 13 | for (i = 0; i < strlen(msg); i++) { 14 | if (msg[i] == '1') { 15 | bits++; 16 | } 17 | } 18 | 19 | printf("%s", msg); 20 | 21 | printf("%d\n", (bits % 2)); 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /C/Iniciante/2823/2823.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N, i; 5 | long double soma=0; 6 | 7 | scanf("%d",&N); 8 | 9 | int custo[N], periodo[N]; 10 | 11 | for(i=0; i 3 | 4 | void main () 5 | { 6 | int casos, i, compradas, troca; 7 | 8 | scanf("%d", &casos); 9 | 10 | while (casos--) 11 | { 12 | scanf("%d %d", &compradas, &troca); 13 | 14 | int contador = 0; 15 | 16 | for (i = compradas; i >= troca; i -= troca) 17 | contador++; 18 | 19 | printf("%d\n", contador + i); 20 | 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /Python/Iniciante/1095.py: -------------------------------------------------------------------------------- 1 | # Problema 1095 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Declaração das variáveis iniciais 'j' e 'i' 4 | j=60 5 | i=1 6 | 7 | # Criação do loop while que realizará o laço ate 'j' ser menor que zero 8 | while j >= 0: 9 | 10 | # Printando a saída 'i' e 'j' 11 | print(f'I={i} J={j}') 12 | 13 | # Diminuindo em 5 o valor da variável 'j' e incrementando em 3 a variável 'i' 14 | j=j-5 15 | i=i+3 16 | -------------------------------------------------------------------------------- /C/Iniciante/1020/1020.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int idade, anos, meses, dias; 6 | 7 | scanf("%d", &idade); 8 | 9 | anos = idade/365; 10 | meses = (idade - anos*365)/30; 11 | dias = ((idade - anos*365) - meses*30); 12 | 13 | printf ("%d ano(s)\n", anos); 14 | printf ("%d mes(es)\n", meses); 15 | printf ("%d dia(s)\n", dias); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /C/Iniciante/1072/1072.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int cont, n, valor, dentro = 0, fora = 0; 5 | scanf("%d", &n); 6 | for (cont = 1; cont <= n; cont++) 7 | { 8 | scanf("%d", &valor); 9 | if (valor >= 10 && valor <= 20) 10 | dentro++; 11 | else 12 | fora++; 13 | } 14 | printf("%d in\n", dentro); 15 | printf("%d out\n", fora); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /C/Iniciante/2752/2752.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | char frase[50] = "AMO FAZER EXERCICIO NO URI"; 6 | 7 | printf("<%s>\n", frase); 8 | printf("<%30s>\n", frase); 9 | printf("<%.20s>\n", frase); 10 | printf("<%-20s>\n", frase); 11 | printf("<%-30s>\n", frase); 12 | printf("<%.30s>\n", frase); 13 | printf("<%30.20s>\n", frase); 14 | printf("<%-30.20s>\n", frase); 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /Python/Iniciante/3145.py: -------------------------------------------------------------------------------- 1 | # Problema 3145 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura dos números N e X, convertendo-os para float através da função map 4 | N, X = map(float, input().split(' ')) 5 | 6 | # Cálculo dos dias que levarão para o grupo chegar até a Montanha Solitária 7 | dias = X/(N+2) 8 | 9 | # Exibição do resultado da divisão na tela, utilizando 2.f para exibir apenas 10 | # dois dígitos decimais 11 | print(f'{dias:.2f}') 12 | -------------------------------------------------------------------------------- /C/Iniciante/1150/1150.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int X, Z, soma, res; 6 | 7 | res = 1; 8 | scanf("%d", &X); 9 | 10 | do { 11 | scanf("%d", &Z); 12 | } while (Z <= X); 13 | 14 | soma = X; 15 | 16 | while (soma <= Z) { 17 | X++; 18 | soma = soma + X; 19 | res++; 20 | } 21 | 22 | printf("%d\n", res); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /C/Iniciante/1865/1865.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int C, contagem, newtons; 6 | char nome[10]; 7 | scanf("%d", &C); 8 | for (contagem=1; contagem<=C; contagem++) 9 | { 10 | scanf("%s", nome); 11 | scanf("%d", &newtons); 12 | if (nome[0]=='T' && nome[1]=='h' && nome[2]=='o' && nome[3]=='r') 13 | printf("Y\n"); 14 | else printf("N\n"); 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /Python/Iniciante/1096.py: -------------------------------------------------------------------------------- 1 | # Problema 1096 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Declaração das variáveis 4 | i=1 5 | j=7 6 | 7 | # Início do primeiro loop 8 | for contador1 in range(5): 9 | # Início do segundo loop 10 | for contador2 in range(3): 11 | # Imprimindo a saída e incrementando a variável 'j' 12 | print(f'I={i} J={j}') 13 | j=j-1 14 | # Incremento a variável 'i' e setando 'j' igual à 7 novamente 15 | i=i+2 16 | j=7 17 | -------------------------------------------------------------------------------- /Python/Iniciante/3209.py: -------------------------------------------------------------------------------- 1 | # Problema 3209 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do número de testes 4 | n = int(input()) 5 | 6 | # Leitura dos testes 7 | for i in range(n): 8 | k, *filtros = map(int, input().split()) 9 | 10 | # O número total de tomadas disponível é: 11 | # Soma das tomadas de todos os filtros 12 | # Menos as tomadas em que serão ligados os filtros 13 | # Mais a tomada da parede 14 | print(sum(filtros) - k + 1) -------------------------------------------------------------------------------- /Python/Iniciante/2987.py: -------------------------------------------------------------------------------- 1 | # Problema 2987 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Recebendo do usuário a entrada de uma letra maiúscula. 4 | letra = input() 5 | 6 | # Usando a tabela ASCII, cada caracter tem um código, podendo ser recebido pela função "ord()", e sabendo que o A tem código 65, subtraímos 64 de cada letra que teremos a posição dela. 7 | posLetra = ord(letra) - 64 8 | 9 | # Mostrando a posição em que a letra se encontra. 10 | print(posLetra) -------------------------------------------------------------------------------- /Python/Iniciante/3147.py: -------------------------------------------------------------------------------- 1 | # Problema 3147 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lendo as variáveis de entrada 4 | H,E,A,O,W,X= map(int, input().split(' ')) 5 | 6 | # Realizando a soma dos exércitos do bem e do mal. Caso o exército do bem seja maior ou igual ao exercito do mal, Middle-earth estará salva 7 | if(H+E+A+X) >= (O+W): 8 | print(f'Middle-earth is safe.') 9 | 10 | # Caso contrário Sauron retornará 11 | else: 12 | print(f'Sauron has returned.') -------------------------------------------------------------------------------- /C/Iniciante/1133/1133.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int X, Y, i; 5 | 6 | scanf("%d %d", &X, &Y); 7 | 8 | if(X > Y) 9 | for(i = Y+1; i < X; i++) 10 | if(i % 5 == 2 || i % 5 == 3) 11 | printf("%d\n", i); 12 | 13 | else if(Y >= X) 14 | for(i = X+1; i < Y; i++) 15 | if(i % 5 == 2 || i % 5 == 3) 16 | printf("%d\n", i); 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/1164/1164.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int nCasos, valor, i, j, soma; 5 | scanf("%d", &nCasos); 6 | 7 | for(i=0; i 2 | #include 3 | 4 | int main() { 5 | int n, i, algoz = 0, menor = 999; 6 | int *v; 7 | 8 | scanf("%d",&n); 9 | v = (int *) malloc(n * sizeof(int)); 10 | for (i=0;i 2 | 3 | int main(){ 4 | double i = 0; 5 | int k, contador=0; 6 | 7 | while(i<2){ 8 | for(k=1;k<=3;k++){ 9 | 10 | if (contador%5 == 0) 11 | printf("I=%.0lf J=%.0lf\n",i,(i+k)); 12 | else 13 | printf("I=%.1lf J=%.1lf\n",i,(i+k)); 14 | } 15 | contador += 1; 16 | i += 0.2; 17 | } 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /C/Iniciante/2543/2543.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | int totalGameplays, idAutor, idPublicado, jogo, contador, i; 6 | 7 | while(scanf("%d %d", &totalGameplays, &idAutor) != EOF){ 8 | 9 | contador = 0; 10 | 11 | for(i = 0; i < totalGameplays; i++){ 12 | scanf("%d %d", &idPublicado, &jogo); 13 | 14 | if(idAutor == idPublicado && jogo == 0) 15 | contador++; 16 | } 17 | 18 | printf("%d\n", contador); 19 | } 20 | return 0; 21 | } -------------------------------------------------------------------------------- /C/Iniciante/2551/2551.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int N, recorde_D, recorde_T, i, T, D; 5 | 6 | while (scanf("%d", &N) != EOF) { 7 | 8 | recorde_D = 0; 9 | recorde_T = 1; 10 | 11 | for (i = 1; i <= N; i++) { 12 | scanf("%d %d", &T, &D); 13 | 14 | if (D*recorde_T > recorde_D*T) { 15 | printf("%d\n", i); 16 | recorde_D = D; 17 | recorde_T = T; 18 | } 19 | } 20 | } 21 | return 0; 22 | } -------------------------------------------------------------------------------- /Python/Iniciante/1020.py: -------------------------------------------------------------------------------- 1 | # Problema 1020 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Vamos ler o número de dias e converter o valor para inteiro 4 | dias = int(input()) 5 | 6 | # Começamos calculando o número de anos 7 | anos = dias//365 8 | dias = dias%365 9 | 10 | # Depois o número de meses 11 | meses = dias//30 12 | dias = dias%30 13 | 14 | # Então printamos todos os valores 15 | print(f'{anos} ano(s)') 16 | print(f'{meses} mes(es)') 17 | print(f'{dias} dia(s)') 18 | -------------------------------------------------------------------------------- /Python/Iniciante/2780.py: -------------------------------------------------------------------------------- 1 | # Problema 2780 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Entrada de dados, sendo o valor da distância do robô para a cesta 4 | distancia = int(input()) 5 | 6 | # Testando se a distância é válida e apresentando a saída 7 | if(distancia<0 or distancia>2000): 8 | print("Distância inválida") 9 | else: 10 | if(distancia<=800): 11 | print("1") 12 | elif(distancia<=1400): 13 | print("2") 14 | else: 15 | print("3") -------------------------------------------------------------------------------- /C/Iniciante/2523/2523.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int tamanho = 0,posicao_letras, i = 0; 6 | char letras[25]; 7 | while(scanf("%s", letras) != EOF) { 8 | i = 0; 9 | scanf("%d", &tamanho); 10 | while (i < tamanho) { 11 | scanf("%d",&posicao_letras); 12 | printf("%c",letras[posicao_letras-1]); 13 | i++; 14 | } 15 | printf("\n"); 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /C/Iniciante/1043/1043.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | float A, B, C, resultado; 4 | 5 | scanf("%f %f %f", &A, &B, &C); 6 | 7 | if ((A < (B + C)) && 8 | (B < (A + C)) && 9 | (C < (B + A))) { 10 | resultado = A + B + C; 11 | printf("Perimetro = %.1f\n", resultado); 12 | } 13 | else { 14 | resultado = ((A + B) * C) / 2; 15 | printf("Area = %.1f\n", resultado); 16 | } 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /C/Iniciante/1064/1064.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int contPositivos = 0; 6 | float valor, soma = 0; 7 | 8 | int i; 9 | for( i = 0; i < 6; i++){ 10 | scanf("%f", &valor); 11 | if( valor > 0){ 12 | soma = soma + valor; 13 | contPositivos++; 14 | } 15 | } 16 | 17 | printf("%d valores positivos\n", contPositivos); 18 | printf("%.1f\n", soma/contPositivos); 19 | 20 | return (0); 21 | } -------------------------------------------------------------------------------- /C/Iniciante/2779/2779.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main (){ 4 | 5 | int i, aux; 6 | int qtdTotal, compradas; 7 | int album[101] = {0}; 8 | int faltam = 0; 9 | 10 | scanf("%d", &qtdTotal); 11 | scanf("%d", &compradas); 12 | 13 | for (i = 0; i < compradas; i++){ 14 | scanf("%d", &aux); 15 | album[aux] = 1; 16 | } 17 | 18 | for (i = 1; i <= qtdTotal; i++) 19 | if (!album[i]) 20 | faltam++; 21 | 22 | printf("%d\n", faltam); 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /C/Iniciante/2826/2826.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char firstWord[20], secondWord[20]; 6 | 7 | scanf("%s",&firstWord); 8 | scanf("%s",&secondWord); 9 | 10 | if(strcmp(firstWord, secondWord) < 0){ 11 | printf("%s\n",firstWord); 12 | printf("%s\n",secondWord); 13 | } 14 | 15 | else if(strcmp(firstWord, secondWord) > 0){ 16 | printf("%s\n",secondWord); 17 | printf("%s\n",firstWord); 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /C/Iniciante/2982/2982.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | char op; 5 | int i, n, valor, total = 0; 6 | scanf("%d%*c", &n); 7 | 8 | for (i = 0; i < n; ++i){ 9 | scanf("%c %d%*c", &op, &valor); 10 | 11 | if (op == 'G') 12 | total -= valor; 13 | else 14 | total += valor; 15 | } 16 | 17 | if (total >= 0) 18 | printf("A greve vai parar.\n"); 19 | else 20 | printf("NAO VAI TER CORTE, VAI TER LUTA!\n"); 21 | 22 | return 0; 23 | 24 | } -------------------------------------------------------------------------------- /C/Strings/2691/2691.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | int X, Y, i, N, j; 7 | unsigned char vezes; 8 | scanf("%d", &N); 9 | 10 | for (i = 0; i < N; i++) 11 | { 12 | 13 | scanf("%d%c%d", &X, &vezes, &Y); 14 | 15 | if (X == Y) 16 | for (j = 5; j <= 10; j++) 17 | printf("%d x %d = %d\n", X, j, X*j); 18 | else 19 | for (j = 5; j <= 10; j++) 20 | printf("%d x %d = %d && %d x %d = %d\n", X, j, X*j, Y, j, Y*j); 21 | } 22 | return 0; 23 | } -------------------------------------------------------------------------------- /Python/Iniciante/1009.py: -------------------------------------------------------------------------------- 1 | # Problema 1009 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Entrada de dados 4 | # Uso do caster "float" na linha 4 e 5 para forçar a entrada seja float 5 | nome = input() 6 | salario = float(input()) 7 | total_vendas = float(input()) 8 | 9 | # Calculo do total recebido pelo vendedor 10 | total_recebido = salario + (total_vendas*0.15) 11 | 12 | # Mostrando ao usuário com duas casas decimais com o ".2f" 13 | print(f"TOTAL = R$ {total_recebido:.2f}") 14 | -------------------------------------------------------------------------------- /C/Iniciante/1847/1847.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | int a, b, c; 6 | 7 | scanf("%d %d %d", &a, &b, &c); 8 | 9 | if(a>b){ 10 | if(c=(a-b)){ 11 | printf(":(\n"); 12 | } 13 | else 14 | printf(":)\n"); 15 | } 16 | else if(b>a){ 17 | if(c>b && (c-b)>=(b-a)) 18 | printf(":)\n"); 19 | else 20 | printf(":(\n"); 21 | } 22 | else if(b==a && c>b) 23 | printf(":)\n"); 24 | else 25 | printf(":(\n"); 26 | 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /C/Iniciante/2061/2061.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | int N, i, M; 7 | char str[20]; 8 | 9 | scanf("%d %d", &N, &M); 10 | 11 | for (i = 0; i < M; i++) 12 | { 13 | scanf("%s", str); 14 | 15 | if(strcmp(str, "fechou")==0){ 16 | N++; 17 | } 18 | else if(strcmp(str, "clicou")==0){ 19 | N--; 20 | } 21 | 22 | } 23 | printf("%d\n", N); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /C/Iniciante/2963/2963.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int candidatos, carlos, i; 5 | 6 | scanf("%d %d", &candidatos, &carlos); 7 | candidatos = candidatos - 1; 8 | while (candidatos--) { 9 | scanf("%d", &i); 10 | if (i>carlos) { 11 | carlos = -1; 12 | } 13 | } 14 | if (carlos > -1) { 15 | printf("S\n"); 16 | } 17 | else { 18 | printf("N\n"); 19 | } 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /C/Iniciante/1079/1079.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | float nota1, nota2, nota3, total, media; 5 | 6 | int cont, casos; 7 | 8 | scanf("%d", &casos); 9 | 10 | for(cont=1; cont<=casos; cont++){ 11 | scanf("%f%f%f", ¬a1, ¬a2, ¬a3); 12 | 13 | total = nota1*2.0 + nota2*3.0 + nota3*5.0; 14 | 15 | media = total/10.0; 16 | 17 | printf("%.1f\n", media); 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /C/Iniciante/1132/1132.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int X, Y, i, soma; 5 | 6 | scanf("%d %d", &X, &Y); 7 | 8 | soma = 0; 9 | 10 | if(X > Y) 11 | for(i = Y; i <= X; i++) 12 | if(i % 13 != 0) 13 | soma += i; 14 | 15 | else if(Y > X) 16 | for(i = X; i <= Y; i++) 17 | if(i % 13 != 0) 18 | soma += i; 19 | 20 | printf("%d\n", soma); 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /C/Iniciante/1541/1541.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | 6 | int a, b, c, area, lado; 7 | 8 | while(1) 9 | { 10 | scanf("%d", &a); 11 | 12 | if(a==0) 13 | break; 14 | 15 | else 16 | { 17 | scanf("%d%d", &b,&c); 18 | area = a*b; 19 | lado = sqrt((area*100)/c); 20 | printf("%d\n", lado); 21 | } 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /C/Iniciante/2152/2152.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int numTestes, hora, minuto, abriu; 5 | 6 | scanf("%d", &numTestes); 7 | 8 | while(numTestes){ 9 | 10 | scanf("%d %d %d", &hora, &minuto, &abriu); 11 | printf("%02d:%02d - A porta ", hora, minuto); 12 | 13 | if(abriu) 14 | printf("abriu!\n"); 15 | else 16 | printf("fechou!\n"); 17 | 18 | numTestes--; 19 | } 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /Python/Iniciante/1006.py: -------------------------------------------------------------------------------- 1 | # Problema 1006 - Beecrowd - Iniciante - Nível 2 2 | 3 | 4 | # Recebemos os 3 valores de entrada, já utilizando a função float para convertê-los, já que em python todo input retorna uma string 5 | A = float(input()) 6 | B = float(input()) 7 | C = float(input()) 8 | 9 | # Em seguida, calculamos a média utilizando os pesos descritos no exercício e por fim a imprimimos com apenas uma casa decimal 10 | media = (A*2 + B*3 + C*5)/10 11 | 12 | print(f"MEDIA = {media:.1f}") -------------------------------------------------------------------------------- /Python/Iniciante/1117.py: -------------------------------------------------------------------------------- 1 | # Problema 1117 - Beecrowd - Iniciante - Nível 1 2 | # Laço que recebe nota1 na entrada e para apenas se o valor estiver no intervalo [0, 10] 3 | while (nota1 := float(input())) < 0 or nota1 > 10: print('nota invalida') 4 | # Laço que recebe nota2 na entrada e para apenas se o valor estiver no intervalo [0, 10] 5 | while (nota2 := float(input())) < 0 or nota2 > 10: print('nota invalida') 6 | # Mostrando resultado da média na tela 7 | print(f'media = {(nota1+nota2)/2.0}') 8 | -------------------------------------------------------------------------------- /C/Iniciante/1165/1165.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int nCasos, valor, i, j, primo; 5 | scanf("%d", &nCasos); 6 | 7 | for(i=0; i 2 | 3 | int main() { 4 | int entrada[100]; 5 | int maiorValor, posicao=0; 6 | int i; 7 | 8 | for(i=0; i<100; i++){ 9 | scanf("%d",&entrada[i]); 10 | if(entrada[i] > entrada[posicao]){ 11 | maiorValor = entrada[i]; 12 | posicao = i; 13 | } 14 | else{ 15 | maiorValor = entrada[posicao]; 16 | } 17 | } 18 | 19 | printf("%d\n",maiorValor); 20 | printf("%d\n",posicao+1); 21 | 22 | return 0; 23 | 24 | } 25 | -------------------------------------------------------------------------------- /C/Iniciante/1180/1180.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N, posicao=0, menorValor; 5 | 6 | scanf("%d",&N); 7 | int X[N], i; 8 | 9 | for(i=0;i 2 | #include 3 | 4 | int main(){ 5 | int T, N, i; 6 | 7 | scanf("%d", &T); 8 | 9 | while( T > 0){ 10 | 11 | for(i=0; i < T; i++){ 12 | scanf("%d", &N); 13 | 14 | if ( N%2 == 0 ) 15 | printf("%d\n", N*2 - 2); 16 | else 17 | printf("%d\n", N*2 - 1); 18 | } 19 | 20 | scanf("%d", &T); 21 | } 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /C/Iniciante/2670/2670.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() 5 | { 6 | int cafe[3]; 7 | int A1, A2, A3, i, menor; 8 | 9 | scanf("%d %d %d", &A1, &A2, &A3); 10 | 11 | cafe[0] = A2*2 + A3*4; 12 | cafe[1] = A1*2 + A3*2; 13 | cafe[2] = A1*4 + A2*2; 14 | 15 | menor = cafe[0]; 16 | 17 | if(menor > cafe[1]) 18 | menor = cafe[1]; 19 | else if (menor > cafe[2]) 20 | menor = cafe[2]; 21 | 22 | printf("%d\n", menor); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /Python/Iniciante/2061.py: -------------------------------------------------------------------------------- 1 | # Problema 2061 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Entrada de dados, primeiro o número de abas já abertas e o segundo o valor de ações feitas por Péricles 4 | n_abas,n_acoes = map(int,input().split(" ")) 5 | 6 | # Recebendo quais ações foram feitas 7 | for i in range(n_acoes): 8 | acao = input() 9 | if(acao=="fechou"): 10 | n_abas +=1 11 | elif(acao=="clicou"): 12 | n_abas -=1 13 | 14 | # Apresentando o número de abas final 15 | print(n_abas) -------------------------------------------------------------------------------- /Python/Iniciante/2159.py: -------------------------------------------------------------------------------- 1 | # Problema 2159 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Importando o pacote math para utilizar a função log(elemento, base) 4 | import math 5 | 6 | # Leitura da variável de entrada 7 | n = float(input()) 8 | 9 | # Cálculo do valor máximo 10 | minimo=n/math.log(n,2.718281828459045235360287) 11 | 12 | # Cálculo do valor mínimo 13 | maximo=1.25506*(n/math.log(n,2.718281828459045235360287)) 14 | 15 | # Printando o resultado 16 | print(f'{minimo:.1f} {maximo:.1f}') 17 | 18 | -------------------------------------------------------------------------------- /Python/Iniciante/2748.py: -------------------------------------------------------------------------------- 1 | # Problema 2748 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Simplesmente impressão de string formatada 4 | print("---------------------------------------") 5 | print("| Roberto |") 6 | print("| |") 7 | print("| 5786 |") 8 | print("| |") 9 | print("| UNIFEI |") 10 | print("---------------------------------------") -------------------------------------------------------------------------------- /C/Iniciante/1037/1037.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () 4 | { 5 | 6 | float valor; 7 | scanf("%f", &valor); 8 | 9 | if (valor >= 0 && valor <= 25) 10 | printf("Intervalo [0,25]\n"); 11 | else if (valor > 25 && valor <= 50) 12 | printf("Intervalo (25,50]\n"); 13 | else if (valor > 50 && valor <= 75) 14 | printf("Intervlo (50,75]\n"); 15 | else if (valor > 75 && valor <= 100) 16 | printf("Intervalo (75,100]\n"); 17 | else 18 | printf("Fora de intervalo\n"); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /C/Iniciante/2547/2547.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int n, min, max, i; 6 | int altura, visitantes = 0; 7 | 8 | while (scanf ("%d %d %d", &n, &min, &max) != EOF) 9 | { 10 | for ( i = 0; i < n; i++) 11 | { 12 | scanf ("%d", &altura); 13 | if (altura >= min && altura <= max) 14 | visitantes++; 15 | } 16 | printf ("%d\n", visitantes); 17 | visitantes = 0; 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Python/Iniciante/1113.py: -------------------------------------------------------------------------------- 1 | # Problema 1113 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicializa x e y com valores diferentes 4 | x, y = 0, 1 5 | 6 | # Loop lendo as entradas até serem iguais 7 | while x != y: 8 | # Leitura de multiplas variáveis em uma linha 9 | x, y = map(int, input().split(' ')) 10 | # Caso x e y forem iguais, não haverá print 11 | if x != y: 12 | # Imprime Crescente se crescente e Decrescente caso contrário 13 | print("Crescente" if x < y else "Decrescente") -------------------------------------------------------------------------------- /Python/Iniciante/2172.py: -------------------------------------------------------------------------------- 1 | # Problema 2172 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicializa as variáveis e atribui 4 | # os valores de X e EXP nessas variáveis 5 | X, EXP = map(int, input().split(' ')) 6 | 7 | # Executa a operação de imprimir o valor de 8 | # EXP multiplicado por X e atribui novos valores 9 | # a essas variáveis, continuando o laço 10 | # enquanto ambas não tiverem valor igual a 0 11 | while X != 0 and EXP != 0: 12 | print(X*EXP) 13 | X, EXP = map(int, input().split(' ')) 14 | -------------------------------------------------------------------------------- /C/Iniciante/2164/2164.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | 6 | double part1, part2, part3, potencia1, potencia2; 7 | double n; 8 | 9 | scanf("%lf", &n); 10 | 11 | part1 = (1+sqrt(5))/2; 12 | part2 = (1-sqrt(5))/2; 13 | potencia1 = pow(part1, n); 14 | potencia2 = pow(part2, n); 15 | part3 = ((potencia1 - potencia2)/sqrt(5)); 16 | 17 | 18 | printf("%.1lf\n", part3); 19 | 20 | return 0; 21 | } 22 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /C/Strings/1257/1257.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | char linha[51]; 6 | int n, l, i, j, k, total; 7 | 8 | scanf("%d", &n); 9 | for(i=0;i 2 | #include 3 | #include 4 | 5 | int main (){ 6 | 7 | char numero[10]; 8 | char corte[7]; 9 | 10 | int inteiro; 11 | double fracionario, cutoff; 12 | 13 | while( scanf("%s %s", numero, corte) != EOF){ 14 | 15 | inteiro = atoi(numero); 16 | fracionario = atof(numero) - inteiro; 17 | cutoff = atof(corte); 18 | 19 | if(fracionario > cutoff) 20 | inteiro++; 21 | 22 | printf("%d\n", inteiro); 23 | } 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /Python/Iniciante/1079.py: -------------------------------------------------------------------------------- 1 | # Problema 1079 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura da variavel 'n' que será número de vezes que será calculada a média ponderada 4 | n = int(input()) 5 | 6 | # Loop que lerá 'n' vezes as notas dos alunos 7 | for i in range(n): 8 | 9 | # Leitura das três notas 10 | a, b, c = map(float, input().split(' ')) 11 | 12 | # Cálculo da média ponderada 13 | media_ponderada = (a*2 + b*3 + c*5)/10 14 | 15 | # Print da média ponderada 16 | print(f'{media_ponderada:.1f}') 17 | -------------------------------------------------------------------------------- /Python/Strings/1168.py: -------------------------------------------------------------------------------- 1 | # Problema 1168 - Beecrowd - Strings - Nível 3 2 | 3 | # O custo de leds para cada um dos algarismos 0~9 4 | custo = [6,2,5,5,4,5,6,3,7,6] 5 | 6 | # Lendo quantos casos serão lidos 7 | loops = int(input()) 8 | 9 | for i in range(loops): 10 | # Lendo o número 11 | numero = input() 12 | sum = 0 13 | 14 | # Adicionando o custo de cada número na soma 15 | for i in numero: 16 | sum += custo[int(i)] 17 | 18 | # Imprimindo o resultado 19 | print(f'{sum} leds') -------------------------------------------------------------------------------- /C/Strings/2150/2150.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | 6 | char vogais[40], texto[500]; 7 | int contaVogais, i, j; 8 | 9 | while(scanf("%s ", vogais) != EOF){ 10 | 11 | fgets(texto, sizeof(texto), stdin); 12 | 13 | contaVogais = 0; 14 | 15 | for(i=0;i 2 | #include 3 | 4 | int main() 5 | { 6 | int h_inicio, h_fim; 7 | scanf("%d%d", &h_inicio, &h_fim); 8 | if (h_inicio>12 && h_fim<12) 9 | { 10 | printf("O JOGO DUROU %d HORA(S)\n", abs(abs(h_inicio-12)-(h_fim+12))); 11 | } 12 | if (h_inicio==0&&h_fim==0 || h_inicio==h_fim) 13 | { 14 | printf("O JOGO DUROU 24 HORA(S)\n"); 15 | } 16 | if (h_inicio<12&&h_fim>12) 17 | { 18 | printf("O JOGO DUROU %d HORA(S)\n", abs((h_inicio+12)-abs(h_fim+12))); 19 | } 20 | 21 | } -------------------------------------------------------------------------------- /C/Iniciante/2748/2748.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | printf("---------------------------------------\n"); 6 | printf("| Roberto |\n"); 7 | printf("| |\n"); 8 | printf("| 5786 |\n"); 9 | printf("| |\n"); 10 | printf("| UNIFEI |\n"); 11 | printf("---------------------------------------\n"); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /C/Iniciante/3065/3065.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int operando, expressao, i, teste = 0, resultado; 5 | scanf("%d", &operando); 6 | while (operando != 0) { 7 | resultado = 0; 8 | teste += 1; 9 | for (i=1; i<=operando; i++) { 10 | scanf("%d", &expressao); 11 | resultado += expressao; 12 | } 13 | printf("Teste %d\n", teste); 14 | printf("%d\n\n", resultado); 15 | scanf("%d", &operando); 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /C/Iniciante/1848/1848.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | char entrada[10]; 6 | int grito = 3, piscada = 0; 7 | 8 | 9 | while(grito){ 10 | fgets(entrada, sizeof(entrada), stdin); 11 | 12 | if(entrada[0]=='c'){ 13 | printf("%d\n", piscada); 14 | piscada = 0; 15 | grito--; 16 | } 17 | else{ 18 | if(entrada[0] == '*') 19 | piscada += 4; 20 | if(entrada[1] == '*') 21 | piscada += 2; 22 | if(entrada[2] == '*') 23 | piscada += 1; 24 | } 25 | 26 | } 27 | return 0; 28 | } -------------------------------------------------------------------------------- /Python/Iniciante/1043.py: -------------------------------------------------------------------------------- 1 | # Problema 1043 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Recebe o módulo de cada lado 4 | ladoA, ladoB, ladoC = map(float, input().split()) 5 | 6 | # Verifica se é possível formar um triângulo com os valores informados 7 | if ladoA + ladoB > ladoC and ladoA + ladoC > ladoB and ladoB + ladoC > ladoA: 8 | print(f"Perimetro = {(ladoA + ladoB + ladoC):.1f}") 9 | 10 | # Imprime a área do trapézio caso os lados não formem triângulo 11 | else: 12 | print(f"Area = {((ladoA + ladoB)*ladoC/2):.1f}") 13 | -------------------------------------------------------------------------------- /C/Iniciante/1159/1159.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int X, i, soma; 5 | scanf("%d",&X); 6 | 7 | while(X != 0){ 8 | soma = 0; 9 | for(i=0;i<5;i++){ 10 | if(X%2 == 0){ 11 | soma += X; 12 | X+=2; 13 | } 14 | else{ 15 | soma += X + 1; 16 | X += 2; 17 | } 18 | } 19 | 20 | printf("%d\n",soma); 21 | scanf("%d",&X); 22 | } 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /C/Strings/1871/1871.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int m, n, soma, i, posi; 6 | char num[21]; 7 | 8 | while(1){ 9 | scanf("%d %d", &m, &n); 10 | 11 | if(m == 0 && n == 0){ 12 | break; 13 | } 14 | 15 | soma = m + n; 16 | posi = sprintf(num, "%d", soma); 17 | 18 | num[posi + 1] = '\0'; 19 | 20 | for(i = 0; i < posi; i++) { 21 | if(num[i] != '0') { 22 | printf("%c", num[i]); 23 | } 24 | } 25 | printf("\n"); 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Python/Iniciante/1037.py: -------------------------------------------------------------------------------- 1 | # Problema 1037 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Recebe o valor 4 | valor = float(input()) 5 | 6 | # Verifica em qual intervalo o valor está e imprime na sáida padrão 7 | if 100 < valor: 8 | print("Fora de intervalo") 9 | elif 75 < valor: 10 | print("Intervalo (75,100]") 11 | elif 50 < valor: 12 | print("Intervalo (50,75]") 13 | elif 25 < valor: 14 | print("Intervalo (25,50]") 15 | elif 0 <= valor: 16 | print("Intervalo [0,25]") 17 | else: 18 | print("Fora de intervalo") 19 | -------------------------------------------------------------------------------- /C/Strings/2356/2356.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | char resistente(char *, char *); 5 | 6 | int main(){ 7 | 8 | char a[101], b[101]; 9 | 10 | while(scanf("%s", a) != EOF){ 11 | scanf("%s", b); 12 | if(resistente(a, b)) 13 | printf("Resistente\n"); 14 | else 15 | printf("Nao resistente\n"); 16 | } 17 | 18 | return 0; 19 | } 20 | 21 | char resistente(char *a, char *b){ 22 | char *contem; 23 | 24 | contem = strstr(a, b); 25 | 26 | if(contem) 27 | return 1; 28 | return 0; 29 | } -------------------------------------------------------------------------------- /C/Strings/2678/2678.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char c; 6 | char *teclado = "22233344455566677778889999"; 7 | 8 | while (scanf("%c", &c) != EOF) { 9 | if ('a' <= c && c <= 'z') 10 | printf("%c", teclado[c-'a']); 11 | if ('A' <= c && c <= 'Z') 12 | printf("%c", teclado[c-'A']); 13 | if ('0' <= c && c <= '9') 14 | printf("%c", c); 15 | if (c == '\n' || c == '*' || c == '#') 16 | printf("%c", c); 17 | } 18 | 19 | printf("\n"); 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /Python/Iniciante/1067.py: -------------------------------------------------------------------------------- 1 | # Problema 1067 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Recebe o valor que será considerado para imprimir os ímpares. 4 | valor = int(input()) 5 | 6 | # A expressão int((valor - 1)/2) indica quantos ímpares existem até valor n, 7 | # dado que um k-ésimo número ímpar pode ser expresso por 2k + 1 = n, logo, 8 | # o k máximo pode ser expresso por k == int((n - 1)/2). 9 | # Considerando que range(n) irá iterar n - 1 vezes, adicionamos mais um. 10 | for i in range(int((valor - 1)/2) + 1): 11 | print(2*i + 1) 12 | -------------------------------------------------------------------------------- /C/Iniciante/1010/1010.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int codigo, numeroPecas; 6 | float valorPeca, valorTotal; 7 | valorTotal = 0; 8 | 9 | scanf("%d %d %f", &codigo, &numeroPecas, &valorPeca); 10 | 11 | valorTotal = valorTotal + (numeroPecas * valorPeca); 12 | 13 | scanf("%d %d %f", &codigo, &numeroPecas, &valorPeca); 14 | 15 | valorTotal = valorTotal + (numeroPecas * valorPeca); 16 | 17 | printf("VALOR A PAGAR: R$ %.2f\n", valorTotal); 18 | 19 | return (0); 20 | } 21 | -------------------------------------------------------------------------------- /C/Iniciante/1158/1158.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int N, i,j, X, Y, soma; 5 | scanf("%d",&N); 6 | 7 | for(i = 0; i < N; i++){ 8 | scanf("%d %d",&X, &Y); 9 | soma = 0; 10 | for(j=0;j 2 | #include 3 | 4 | int main(){ 5 | int N, T, antes, i; 6 | scanf("%d",&N); 7 | for(i=0;i 2 | #include 3 | 4 | int main() { 5 | int A, B, C, D; 6 | int soma1=0, soma2=0; 7 | bool soma1_maior=false, par=false; 8 | 9 | scanf("%d %d %d %d", &A, &B, &C, &D); 10 | 11 | soma1 = C+D; 12 | soma2 = A+B; 13 | if(soma1 > soma2) 14 | soma1_maior = true; 15 | 16 | if(A%2 == 0) 17 | par = true; 18 | 19 | if(B>C && D>A && soma1_maior && C>=0 && D>=0 && par) 20 | printf("Valores aceitos\n"); 21 | else 22 | printf("Valores nao aceitos\n"); 23 | 24 | return 0; 25 | 26 | } 27 | -------------------------------------------------------------------------------- /C/Iniciante/2540/2540.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | int N, v, i, soma; 7 | 8 | while (scanf("%i", &N) != EOF) 9 | { 10 | soma = 0; 11 | for (i = 0; i < N; i++) 12 | { 13 | scanf("%i", &v); 14 | soma += v; 15 | } 16 | if (soma >= (N / (3 * 1.0f)) * 2) 17 | { 18 | printf("impeachment\n"); 19 | } 20 | else 21 | { 22 | printf("acusacao arquivada\n"); 23 | } 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /C/Iniciante/2747/2747.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int i, j; 6 | 7 | for (i = 0; i < 7; i++) 8 | { 9 | for (j = 0; j < 39; j++) 10 | { 11 | if (i == 0 || i == 6) 12 | { 13 | printf("-"); 14 | } 15 | else if (j == 0 || j == 38) 16 | printf("|"); 17 | else 18 | { 19 | printf(" "); 20 | } 21 | } 22 | printf("\n"); 23 | } 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /Python/Iniciante/2147.py: -------------------------------------------------------------------------------- 1 | # Problema 2147 - Beecrowd - Iniciante - Nível 2 2 | 3 | #Recebe a quantidade de entradas que o teste terá 4 | numero_testes = int(input()) 5 | 6 | #Realiza um loop até que sejam colocadas o número de entradas digitadas acima 7 | for i in range(numero_testes): 8 | 9 | #Recebe a entrada e converse seus caracteres em uma quantidade numérica 10 | caracteres = len(input()) 11 | 12 | #Mostra para o usuário quantos "segundos" demorou para digitar a quantidade de caracteres 13 | print("%.2f" % (caracteres*0.01)) -------------------------------------------------------------------------------- /C/Strings/1272/1272.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | int N, i, j; 6 | char texto[52], mensagemOculta[52]; 7 | 8 | scanf("%d ", &N); 9 | 10 | while(N>0){ 11 | 12 | fgets(texto, sizeof(texto), stdin); 13 | 14 | j = 0; 15 | 16 | for(i = 0; i < strlen(texto)-1; i++){ 17 | 18 | if(texto[i] != ' ' && (texto[i-1] == ' ' || !i)) 19 | mensagemOculta[j++] = texto[i]; 20 | } 21 | 22 | mensagemOculta[j] = '\0'; 23 | 24 | printf("%s\n", mensagemOculta); 25 | N--; 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /C/Iniciante/1038/1038.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int cod, quant; 5 | double total; 6 | 7 | scanf("%d %d", &cod, &quant); 8 | 9 | switch (cod) 10 | { 11 | case 1: 12 | total = quant * 4; 13 | break; 14 | case 2: 15 | total = quant * 4.5; 16 | break; 17 | case 3: 18 | total = quant * 5; 19 | break; 20 | case 4: 21 | total = quant * 2; 22 | break; 23 | case 5: 24 | total = quant * 1.5; 25 | break; 26 | default: 27 | break; 28 | } 29 | 30 | printf("Total: R$ %.2f\n", total); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /C/Iniciante/2059/2059.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int p, j1, j2, r, a, vencedor, soma; 6 | 7 | scanf("%d %d %d %d %d", &p, &j1, &j2, &r, &a); 8 | soma = j1 + j2; 9 | 10 | if((soma%2==0 && p==1) || (soma%2==1 && p==0)) 11 | vencedor = 1; 12 | else 13 | vencedor = 2; 14 | if((r==1 && a==0) || (r==0 && a==1)) 15 | vencedor = 1; 16 | else if(r==1 && a==1) 17 | vencedor=2; 18 | 19 | printf("Jogador %d ganha!\n", vencedor); 20 | 21 | return 0; 22 | } 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /C/Iniciante/2708/2708.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | 6 | int turistas, jipes = 0, turistasFaltantes = 0; 7 | char operacao[10]; 8 | 9 | while (1){ 10 | scanf("%s", operacao); 11 | 12 | if (strcmp(operacao, "ABEND") == 0) 13 | break; 14 | 15 | scanf("%d", &turistas); 16 | if (strcmp(operacao, "SALIDA") == 0) 17 | turistasFaltantes += turistas, jipes++; 18 | else 19 | turistasFaltantes -= turistas, jipes--; 20 | } 21 | 22 | printf("%d\n%d\n", turistasFaltantes, jipes); 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /Python/Iniciante/2747.py: -------------------------------------------------------------------------------- 1 | # Problema 2747 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Utilização de variável e operações em strings de concatenação e repetição de 4 | # caracteres para montar facilmente as linhas solicitadas 5 | tracos = '-'*39 6 | pipe = '|' + ' '*37 + '|' 7 | # Exibição da linha de traços no início da saída 8 | print(tracos) 9 | # Exibição da linha de caracteres "pipe" 5 vezes, como solicitado no enunciado 10 | # do problema 11 | for i in range(5): 12 | print(pipe) 13 | # Exibição da linha de traços no final da saída 14 | print(tracos) 15 | -------------------------------------------------------------------------------- /C/Iniciante/2807/2807.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int N, i; 6 | int fibonacci[40]; 7 | 8 | scanf("%d", &N); 9 | 10 | fibonacci[0]=1; 11 | fibonacci[1]=1; 12 | 13 | for(i=2; i=0; i--){ 17 | 18 | if(i>0) 19 | printf("%d ", fibonacci[i]); 20 | 21 | else 22 | printf("%d\n", fibonacci[i]); 23 | } 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /Python/Iniciante/1132.py: -------------------------------------------------------------------------------- 1 | # Problema 1132 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Entrada de dados 4 | num_1 = int(input()) 5 | num_2 = int(input()) 6 | 7 | # Determinando qual é a maior entrada 8 | if(num_2 2 | 3 | int main() 4 | { 5 | int M, N, i, Sum = 0, aux = 0; 6 | 7 | scanf("%d %d", &M, &N); 8 | 9 | while(M>0&&N>0){ 10 | if(M 0]) 11 | 12 | # Saída de dados 13 | print(f'{positivos} valores positivos') 14 | 15 | -------------------------------------------------------------------------------- /Python/Iniciante/2234.py: -------------------------------------------------------------------------------- 1 | # Problema 2234 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicializa as variáveis a serem utilizadas 4 | # na resolução e atribui os valores nelas 5 | # por meio do uso da entrada padrão 6 | H, P = map(int, input().split(' ')) 7 | 8 | # Imprime o resultado da divisão 9 | # e especifica na formatação da string 10 | # para inprimir com duas casas decimais, 11 | # sendo que o número 2 em {:.2f} está indicando 12 | # a quantidade de casas decimais e o f diz 13 | # que o número passado é do tipo ponto flutuante 14 | print("{:.2f}".format(H/P)) 15 | -------------------------------------------------------------------------------- /C/Iniciante/1041/1041.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | double x, y; 5 | 6 | scanf("%lf %lf", &x, &y); 7 | 8 | if(x == 0 && y == 0) 9 | printf("Origem\n"); 10 | else if(x > 0 && y > 0) 11 | printf("Q1\n"); 12 | else if(x > 0 && y < 0) 13 | printf("Q4\n"); 14 | else if(x < 0 && y > 0) 15 | printf("Q2\n"); 16 | else if(x < 0 && y < 0) 17 | printf("Q3\n"); 18 | else if(x == 0) 19 | printf("Eixo Y\n"); 20 | else if(y == 0) 21 | printf("Eixo X\n"); 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /C/Iniciante/2850/2850.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char condicao[15]; 6 | 7 | while (scanf(" %15[^\n]", condicao) != EOF) { 8 | if (!strcmp(condicao, "esquerda")) 9 | printf("ingles\n"); 10 | else if (!strcmp(condicao, "direita")) 11 | printf("frances\n"); 12 | else if (!strcmp(condicao, "nenhuma")) 13 | printf("portugues\n"); 14 | else if (!strcmp(condicao, "as duas")) 15 | printf("caiu\n"); 16 | } 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /Python/Iniciante/1116.py: -------------------------------------------------------------------------------- 1 | # Problema 1116 - Beecrowd - Iniciante - Nível 1 2 | # Recebendo número de divisões na entrada de dados 3 | N = int(input()) 4 | 5 | # For que repete N vezes 6 | for i in range(N): 7 | # Aplicação da função float através do map na lista de dois valores (X, Y) 8 | X, Y = map(float, input().split(' ')) 9 | # Caso Y não seja igual a 0, é possível efetuar a divisão 10 | if Y != 0: 11 | print(X/Y) 12 | # Caso contrário, mostrar na tela a mensagem "divisao impossivel" 13 | else: 14 | print('divisao impossivel') 15 | -------------------------------------------------------------------------------- /C/Iniciante/2685/2685.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int m; 6 | 7 | while (scanf("%d", &m) != EOF) { 8 | if ((m >= 0) && (m < 90)) 9 | printf("Bom Dia!!\n"); 10 | else if ((m >= 90) && (m < 180)) 11 | printf("Boa Tarde!!\n"); 12 | else if ((m >= 180) && (m < 270)) 13 | printf("Boa Noite!!\n"); 14 | else if ((m >= 270) && (m < 360)) 15 | printf("De Madrugada!!\n"); 16 | else 17 | printf("Bom Dia!!\n"); 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /C/Iniciante/2754/2754.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | double real1, real2; 6 | 7 | real1 = 234.345; 8 | real2 = 45.698; 9 | 10 | printf("%.6lf - %.6lf\n", real1, real2); 11 | printf("%.0lf - %.0lf\n", real1, real2); 12 | printf("%.1lf - %.1lf\n", real1, real2); 13 | printf("%.2lf - %.2lf\n", real1, real2); 14 | printf("%.3lf - %.3lf\n", real1, real2); 15 | 16 | printf("%e - %.e\n", real1, real2); 17 | printf("%E - %.E\n", real1, real2); 18 | 19 | printf("%g - %g\n", real1, real2); 20 | printf("%g - %g\n", real1, real2); 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /Python/Iniciante/1865.py: -------------------------------------------------------------------------------- 1 | # Problema 1865 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do número de casos 4 | casos = int(input()) 5 | # Laço de repetição para cada caso 6 | for i in range(casos): 7 | # Leitura do nome da personagem e da força empregada ao levantar o martelo 8 | nome, forca = input().split(' ') 9 | # Caso o nome digitado seja igual a "Thor", efetua-se um print do caractere 'Y' 10 | if nome == "Thor": 11 | print('Y') 12 | # Caso o nome seja qualquer outro, efetua-se um print do caractere N 13 | else: 14 | print('N') 15 | -------------------------------------------------------------------------------- /Python/Strings/1278.py: -------------------------------------------------------------------------------- 1 | # Problema 1278 - Beecrowd - Strings - Nível 1 2 | 3 | primeiro = True 4 | 5 | while True: 6 | n = int(input()) 7 | 8 | if n == 0: 9 | break 10 | 11 | if primeiro: 12 | primeiro = False 13 | else: 14 | print() 15 | 16 | frases = [] 17 | 18 | for i in range(n): 19 | frase = input() 20 | frase = ' '.join(frase.split()) 21 | frases.append(frase) 22 | 23 | maiorTamanho = max(len(f) for f in frases) 24 | 25 | for frase in frases: 26 | print(frase.rjust(maiorTamanho)) 27 | -------------------------------------------------------------------------------- /C/Iniciante/1181/1181.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | double soma = 0.0, M[12][12]; 5 | char T[2]; 6 | int L, x, y; 7 | scanf("%d", &L); 8 | scanf("%s", &T); 9 | for (x = 0; x <= 11; x++) 10 | { 11 | for (y = 0; y <= 11; y++) 12 | { 13 | scanf("%lf", &M[x][y]); 14 | if (x == L) 15 | soma += M[x][y]; 16 | } 17 | } 18 | if (T[0] == 'S') 19 | printf("%.1lf\n", soma); 20 | else 21 | { 22 | printf("%.1lf\n", soma / 12.0); 23 | } 24 | return 0; 25 | } -------------------------------------------------------------------------------- /C/Iniciante/2770/2770.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () 4 | { 5 | int alturaPlaca, larguraPlaca, qtsPedidos; 6 | int alturaPci, larguraPci, i; 7 | 8 | while (scanf("%d %d %d", &alturaPlaca, &larguraPlaca, &qtsPedidos) != EOF) 9 | { 10 | for (i = 0; i < qtsPedidos; i++) 11 | { 12 | scanf("%d %d", &alturaPci, &larguraPci); 13 | 14 | if ((alturaPci <= alturaPlaca && larguraPci <= larguraPlaca) || (alturaPci <= larguraPlaca && larguraPci <= alturaPlaca)) 15 | printf("Sim\n"); 16 | else 17 | printf("Nao\n"); 18 | } 19 | 20 | } 21 | return 0; 22 | } -------------------------------------------------------------------------------- /C/Iniciante/2782/2782.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int tamanho_sequencia = 1000, sequencia[tamanho_sequencia], escadinhas = 1, i; 6 | 7 | scanf("%d", &tamanho_sequencia); 8 | for (i = 0; i < tamanho_sequencia; i++) { 9 | scanf("%d", &sequencia[i]); 10 | } 11 | for (i = 0; i < (tamanho_sequencia - 2); i++) { 12 | if ( (sequencia[i] - sequencia [i + 1]) != (sequencia[i + 1] - sequencia[i + 2]) ) { 13 | escadinhas = escadinhas + 1; 14 | } 15 | } 16 | printf("%d\n", escadinhas); 17 | return 0; 18 | } -------------------------------------------------------------------------------- /Python/Iniciante/1041.py: -------------------------------------------------------------------------------- 1 | # Problema 1041 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Recebe as coordenadas do ponto 4 | x, y = map(float, input().split()) 5 | 6 | # Verifica em qual quadrante, ou eixo, o ponto está 7 | # e imprime o resultado na saída padrão 8 | if x == 0 and y == 0: 9 | print("Origem") 10 | elif x == 0: 11 | print("Eixo Y") 12 | elif y == 0: 13 | print("Eixo X") 14 | elif x > 0 and y > 0: 15 | print("Q1") 16 | elif x > 0 and y < 0: 17 | print("Q4") 18 | elif x < 0 and y > 0: 19 | print("Q2") 20 | elif x < 0 and y < 0: 21 | print("Q3") 22 | -------------------------------------------------------------------------------- /Python/Iniciante/1933.py: -------------------------------------------------------------------------------- 1 | # Problema 1933 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Entrada dos valores A e B 4 | a, b = map(int, input().split(" ")) 5 | 6 | # Se A é igual B, imprime o valor da variável A 7 | if(a == b): 8 | print(int(a)) 9 | # Se forem diferentes, soma-se o valor de A com o valor de B 10 | # com o valor da diferença entre eles. Então, é dividido por 2 11 | # Isso garante que seja impresso sempre o maior valor entre A e B. 12 | else: 13 | # abs() apresenta o valor em módulo, ou seja, sem sinal. 14 | print(int((a + b + abs(a - b)) / 2)) 15 | -------------------------------------------------------------------------------- /C/Iniciante/1182/1182.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | double soma = 0.0, M[12][12]; 5 | char T[2]; 6 | int C, x, y; 7 | scanf("%d", &C); 8 | scanf("%s", &T); 9 | for (x = 0; x <= 11; x++) 10 | { 11 | for (y = 0; y <= 11; y++) 12 | { 13 | scanf("%lf", &M[x][y]); 14 | if (y == C) 15 | soma += M[x][y]; 16 | } 17 | } 18 | if (T[0] == 'S') 19 | printf("\n%.1lf\n", soma); 20 | else 21 | { 22 | printf("%.1lf\n", soma / 12.0); 23 | } 24 | return 0; 25 | } -------------------------------------------------------------------------------- /C/Iniciante/1957/1957.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(){ 6 | int V; 7 | scanf("%d",&V); 8 | 9 | char digitosHexa[17] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; 10 | char *Vhexa = (char*) malloc(sizeof(char)); 11 | int i = 0; 12 | 13 | while(V > 0){ 14 | Vhexa[i] = digitosHexa[V%16]; 15 | V = V/16; 16 | i = i + 1; 17 | } 18 | 19 | i = i - 1; 20 | 21 | for(i; i >= 0; i--){ 22 | printf("%c", Vhexa[i]); 23 | } 24 | printf("\n"); 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /C/Iniciante/1036/1036.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | double A, B, C; 6 | double delta, R1, R2; 7 | 8 | scanf("%lf %lf %lf", &A, &B, &C); 9 | 10 | if(A == 0) 11 | printf("Impossivel calcular\n"); 12 | 13 | else{ 14 | delta = pow(B,2) - (4*A*C); 15 | 16 | if(delta>=0){ 17 | R1 = (-B +sqrt(delta)) / (2*A); 18 | R2 = (-B -sqrt(delta)) / (2*A); 19 | 20 | printf("R1 = %.5lf\n", R1); 21 | printf("R2 = %.5lf\n", R2); 22 | } 23 | 24 | else 25 | printf("Impossivel calcular\n"); 26 | } 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /Python/Iniciante/2176.py: -------------------------------------------------------------------------------- 1 | # Problema 2176 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicializa a string contendo mensagem S 4 | S = input() 5 | 6 | # Variável para contar a quantidade de dígitos 1 7 | digitos = 0 8 | 9 | # Verifica se a quantidade de dígitos 10 | # com valor igual a 1 é par ou não 11 | for i in S: 12 | if i == "1": 13 | digitos += 1 14 | 15 | # Verifica se a quantidade de dígitos é par, 16 | # testando se é divisível por 2, ou não, 17 | # e em seguida imprimindo a mensagem 18 | if digitos % 2 == 0: 19 | print(S + "0") 20 | else: 21 | print(S + "1") 22 | -------------------------------------------------------------------------------- /Python/Strings/1272.py: -------------------------------------------------------------------------------- 1 | # Problema 1272 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Quantidade de casos teste que serão 4 | # recebidos na entrada padrão 5 | casosTeste = int(input()) 6 | 7 | for i in range(casosTeste): 8 | # Mensagem informada na entrada padrão 9 | mensagem = input() 10 | 11 | # String que irá armazenar a mensagem oculta 12 | mensagemOculta = "" 13 | 14 | # Itera sobre cada palavra 15 | for palavra in mensagem.split(): 16 | # Concatena com a inicial da palavra 17 | mensagemOculta += palavra[0] 18 | 19 | print(mensagemOculta) 20 | -------------------------------------------------------------------------------- /Python/Iniciante/1564.py: -------------------------------------------------------------------------------- 1 | # Problema 1564 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Temos um loop que só se encerra, caso a entrada lida seja EOF 4 | while True: 5 | try: 6 | # Recebemos o número de reclamações ao governo 7 | reclamacoes = int(input()) 8 | 9 | # Caso o número de reclamações seja 0 (zero) 10 | if reclamacoes == 0: 11 | print("vai ter copa!") 12 | # Caso seja diferente de zero 13 | else: 14 | print("vai ter duas!") 15 | 16 | # Caso em que o input chegou em EOF 17 | except EOFError: 18 | break -------------------------------------------------------------------------------- /Python/Strings/2690.py: -------------------------------------------------------------------------------- 1 | # Problema 2690 - Beecrowd - Strings - Nível 3 2 | 3 | # Criando o dicionário 4 | conjunto = ['GQaku', 'ISblv', 'EOYcmw', 'FPZdnx', 'JTeoy', 'DNXfpz', 'AKUgq', 'CMWhr', 'BLVis', 'HRjt'] 5 | conversao = {' ': ''} 6 | for i in range(10): 7 | conversao.update(dict.fromkeys(list(conjunto[i]), str(i))) 8 | 9 | # Loop de quantidade de senhas a serem trocadas 10 | for _ in range(int(input())): 11 | senha = '' 12 | for c in input(): 13 | try: 14 | senha += conversao[c] 15 | except KeyError: 16 | senha += '' 17 | print(senha[:12]) -------------------------------------------------------------------------------- /Python/Strings/2866.py: -------------------------------------------------------------------------------- 1 | # Problema 2866 - Beecrowd - Strings - Nível 2 2 | 3 | # Receber o número de casos de testes. 4 | numTestes = int(input()) 5 | 6 | # Para cada caso teste, recebe uma string e descriptografa. 7 | for i in range(numTestes): 8 | entrada = input() 9 | saida = "" 10 | 11 | # Cada letra é testada, se caso seja minúscula, adiciona na saída 12 | for letra in entrada: 13 | if letra.islower(): 14 | saida += letra 15 | 16 | # Após testar a letra é necessário inverter a saída e apresentá-la 17 | saida = saida[::-1] 18 | print(saida) 19 | -------------------------------------------------------------------------------- /C/Iniciante/1117/1117.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | double nota1, nota2, media; 6 | 7 | do { 8 | scanf("%lf", ¬a1); 9 | if (nota1 < 0 || nota1 > 10) 10 | printf("nota invalida\n"); 11 | } while (nota1 < 0 || nota1 > 10); 12 | 13 | do { 14 | scanf("%lf", ¬a2); 15 | if (nota2 < 0 || nota2 > 10) 16 | printf("nota invalida\n"); 17 | } while (nota2 < 0 || nota2 > 10); 18 | 19 | media = (nota1 + nota2)/2; 20 | printf("media = %0.2lf\n", media); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /Python/Iniciante/1012.py: -------------------------------------------------------------------------------- 1 | # Problema 1012 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Primeiro lemos os três valores 4 | a, b, c = map(float, input().split()) 5 | 6 | pi = 3.14159 7 | 8 | # Então calculamos as áreas 9 | triangulo = a * c / 2 10 | circulo = c**2 * pi 11 | trapezio = (a + b) * c / 2 12 | quadrado = b**2 13 | retangulo = a * b 14 | 15 | # Então printamos as áreas, com três casas decimais 16 | print(f'TRIANGULO: {triangulo:.3f}') 17 | print(f'CIRCULO: {circulo:.3f}') 18 | print(f'TRAPEZIO: {trapezio:.3f}') 19 | print(f'QUADRADO: {quadrado:.3f}') 20 | print(f'RETANGULO: {retangulo:.3f}') -------------------------------------------------------------------------------- /Python/Iniciante/2753.py: -------------------------------------------------------------------------------- 1 | # Problema 2753 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Mesmo que pedido, não iremos declarar 27 variáveis, iremos fazer apenas os prints da forma correta. 4 | 5 | # Usaremos um contador de soma para em cada iteração, somar 1 a mais que o valor anterior. 6 | contador_soma = 0 7 | 8 | # Criaremos um loop de 97 a 97+26(123). 9 | for i in range (97,123): 10 | # Exibimos a soma de i com o contador na forma inteira 11 | # Utilizando a função chr convertemos o número para um caractere da tabela ASCII. 12 | print(f'{i+contador_soma} e {chr(i+contador_soma)}') 13 | -------------------------------------------------------------------------------- /C/Iniciante/3040/3040.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | int casos, altura, tronco, galhos, i; 7 | 8 | scanf("%d", &casos); 9 | 10 | for (i = 0 ; i < casos; ++i) 11 | { 12 | 13 | scanf("%d %d %d", &altura, &tronco, &galhos); 14 | 15 | if (altura >= 200 && altura <= 300) 16 | if (tronco >= 50) 17 | if (galhos >= 150) 18 | { 19 | printf("Sim\n"); 20 | continue; 21 | } 22 | 23 | printf("Nao\n"); 24 | 25 | } 26 | 27 | return 0; 28 | 29 | } -------------------------------------------------------------------------------- /Python/Iniciante/1065.py: -------------------------------------------------------------------------------- 1 | # Problema 1065 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Inicialização da variável 'par' com o valor 0 4 | par = 0 5 | 6 | # 'for' para leitura dos argumentos 7 | for num in range(5): 8 | 9 | num = int(input()) 10 | # Assim que o argumento é recebido, é comparado se 11 | # o resto da divisão por 2 é zero, assim, sendo par 12 | if((num % 2) == 0): 13 | # Se for par, o valor de 'par' é incrementado em 1 14 | par += 1 15 | 16 | # Imprime na tela a quantidade de pares com o texto "valores pares" 17 | print(f'{par} valores pares') 18 | -------------------------------------------------------------------------------- /Python/Iniciante/1134.py: -------------------------------------------------------------------------------- 1 | # Problema 1134 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Declaração de variáveis 4 | combustivel = 1 5 | qtd_alcool = 0 6 | qtd_gasolina = 0 7 | qtd_diesel = 0 8 | 9 | # Entrada de dados até a digitação do digito 4 10 | while(combustivel!=4): 11 | combustivel = int(input()) 12 | if (combustivel==1): 13 | qtd_alcool +=1 14 | elif (combustivel==2): 15 | qtd_gasolina +=1 16 | elif (combustivel==3): 17 | qtd_diesel +=1 18 | 19 | 20 | # Saída de dados 21 | print(f"MUITO OBRIGADO\nAlcool: {qtd_alcool}\nGasolina: {qtd_gasolina}\nDiesel: {qtd_diesel}") -------------------------------------------------------------------------------- /C/Iniciante/1115/1115.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int X, Y; 6 | 7 | do { 8 | scanf("%d%d", &X, &Y); 9 | 10 | if (X > 0) { 11 | if (Y > 0) 12 | printf("primeiro\n"); 13 | else if (Y < 0) 14 | printf("quarto\n"); 15 | } 16 | 17 | else if (X < 0) { 18 | if (Y > 0) 19 | printf("segundo\n"); 20 | else if (Y < 0) 21 | printf("terceiro\n"); 22 | } 23 | } while (X != 0 && Y != 0); 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /C/Strings/1332/1332.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main () 5 | { 6 | int CasoTeste; scanf("%d", &CasoTeste); 7 | 8 | while ( CasoTeste-- ) 9 | { 10 | char a[10]; scanf("%s", a); 11 | 12 | if ( strlen(a) == 5 ) printf("3\n"); 13 | else 14 | { 15 | int cnt = 0; 16 | 17 | if ( a[0] == 'o' ) cnt++; 18 | if ( a[1] == 'n' ) cnt++; 19 | if ( a[2] == 'e' ) cnt++; 20 | 21 | if ( cnt >= 2 ) printf("1\n"); 22 | else printf("2\n"); 23 | } 24 | } 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /C/Strings/2484/2484.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | int i, j, tamanho; 6 | char palavra[110]; 7 | 8 | while(scanf("%s",palavra) != EOF){ 9 | 10 | tamanho = strlen(palavra); 11 | 12 | for(j = 0; j < strlen(palavra); j++){ 13 | for(i=0;i 2 | 3 | int main(){ 4 | int i, j, numero, caso, quantNumeros; 5 | 6 | caso = 0; 7 | 8 | while(scanf("%d", &numero)!= EOF){ 9 | 10 | quantNumeros = 1; 11 | caso++; 12 | 13 | for (i = numero; i > 0; i--) 14 | quantNumeros += i; 15 | 16 | if(numero == 0) 17 | printf("Caso %d: %d numero\n", caso, quantNumeros); 18 | else 19 | printf("Caso %d: %d numeros\n", caso, quantNumeros); 20 | 21 | printf("0"); 22 | 23 | for(i=1;i<=numero;i++){ 24 | for(j=1; j<=i; j++) 25 | printf(" %d", i); 26 | } 27 | printf("\n\n"); 28 | } 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /C/Iniciante/2203/2203.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | 6 | int Xf, Yf, Xi, Yi, V, R1, R2; 7 | double distancia, distX, distY; 8 | 9 | while (scanf("%d %d %d %d %d %d %d", &Xf, &Yf, &Xi, &Yi, &V, &R1, &R2) != EOF) { 10 | 11 | distX = pow((Xi - Xf), 2); 12 | distY = pow((Yi - Yf), 2); 13 | 14 | distancia = sqrt(distX + distY); 15 | 16 | distancia += V * 1.5; 17 | 18 | if (distancia <= (R1 + R2)) { 19 | printf("Y\n"); 20 | } else { 21 | printf("N\n"); 22 | } 23 | } 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /Python/Iniciante/1072.py: -------------------------------------------------------------------------------- 1 | # Problema 1072 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura do valore de n 4 | n = int(input()) 5 | 6 | # Contador para os números dentro do intervalo 7 | # Usando 'in_' pois 'in' é uma palavra reservada 8 | in_ = 0 9 | 10 | # Contador para os números fora do intervalo 11 | out = 0 12 | 13 | # Loop para cada valor 14 | for i in range(n): 15 | # Leitura do valor 16 | x = int(input()) 17 | 18 | # Verificação 19 | if 10 <= x <= 20: 20 | in_ += 1 21 | else: 22 | out += 1 23 | 24 | # Saída apresentando os valores 25 | print(f'{in_} in') 26 | print(f'{out} out') -------------------------------------------------------------------------------- /Python/Iniciante/2717.py: -------------------------------------------------------------------------------- 1 | # Problema 2717 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Leitura da quantidade de horas de trabalho que restam para produzir os dois itens 4 | faltam = int(input()) 5 | # Leitura da quantidade de tempo necessário para produzir cada item (A e B) 6 | A, B = map(int, input().split(' ')) 7 | # Se a soma das horas dos itens A e B ultrapassarem a quantidade de horas que 8 | # faltam para terminar o expediente do duende, exibir a seguinte mensagem na tela 9 | if A + B > faltam: 10 | print('Deixa para amanha!') 11 | # Caso contrário, exibir a seguinte mensagem 12 | else: 13 | print('Farei hoje!') 14 | -------------------------------------------------------------------------------- /C/Iniciante/1012/1012.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | double a, b, c, pi,triangulo, circulo, trapezio, quadrado, retangulo; 5 | 6 | scanf("%lf %lf %lf", &a, &b, &c); 7 | 8 | pi = 3.14159 9 | 10 | triangulo = (a*c)/2; 11 | circulo = pi*c*c; 12 | trapezio = ((a + b)*c)/2; 13 | quadrado = b*b; 14 | retangulo = a*b; 15 | 16 | printf("TRIANGULO: %.3f\n", triangulo); 17 | printf("CIRCULO: %.3f\n", circulo); 18 | printf("TRAPEZIO: %.3f\n", trapezio); 19 | printf("QUADRADO: %.3f\n", quadrado); 20 | printf("RETANGULO: %.3f\n", retangulo); 21 | 22 | return 0; 23 | 24 | } -------------------------------------------------------------------------------- /C/Iniciante/2718/2718.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | unsigned long long X; 5 | int max, seq, N; 6 | scanf("%d", &N); 7 | 8 | while(N--) { 9 | scanf("%llu", &X); 10 | max = 0; 11 | seq = 0; 12 | 13 | while (X > 0) { 14 | if ((X & 1) == 1) { 15 | seq++; 16 | if (seq > max) { 17 | max = seq; 18 | } 19 | } else { 20 | seq = 0; 21 | } 22 | X >>= 1; 23 | } 24 | 25 | printf("%d\n", max); 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /C/Iniciante/2808/2808.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int diferenca(int a, int b) 4 | { 5 | int aux; 6 | 7 | if(a>b) 8 | aux = a-b; 9 | else 10 | aux = b-a; 11 | 12 | return aux; 13 | } 14 | 15 | int main() 16 | { 17 | char inicial[3], final[3]; 18 | int coluna, linha; 19 | 20 | scanf("%s %s", inicial, final); 21 | 22 | coluna = diferenca( inicial[0], final[0]); 23 | linha = diferenca( inicial[1], final[1]); 24 | 25 | if((coluna == 1 && linha == 2) || (coluna == 2 && linha == 1)) 26 | printf("VALIDO\n"); 27 | 28 | else 29 | printf("INVALIDO\n"); 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /Python/Iniciante/2167.py: -------------------------------------------------------------------------------- 1 | #Problema 2167 - Beecrowd - Iniciante - Nível 2 2 | 3 | #Recebe a quantidade de termos que irá ter e abaixo já recebe todos os termos 4 | medida = int(input()) 5 | rpm = input().split() 6 | i= 0 7 | cont = 0 8 | 9 | #Laço para fazer o teste com todos os termos, sendo medida -1 pois dendro do laço ele já compara 10 | #com o termo posterior 11 | while (i < medida - 1): 12 | 13 | #Compara o termo posterior com o termo anterior e se ele for maior o laço é quebrado 14 | if rpm[i+1] < rpm[i]: 15 | cont = i + 2 16 | break 17 | i += 1 18 | 19 | #Imprime o resultado 20 | print(cont) -------------------------------------------------------------------------------- /C/Iniciante/1048/1048.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | float salario, reajuste; 6 | int pct; 7 | scanf("%f", &salario); 8 | 9 | if (salario <= 400) 10 | pct = 15; 11 | else if (salario <= 800) 12 | pct = 12; 13 | else if (salario <= 1200) 14 | pct = 10; 15 | else if (salario <= 2000) 16 | pct = 7; 17 | else 18 | pct = 4; 19 | 20 | reajuste = salario * pct / 100; 21 | salario = salario + reajuste; 22 | printf("Novo salario: %0.2f\nReajuste ganho: %0.2f\nEm percentual: %d %%\n", salario, reajuste, pct); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /C/Iniciante/1074/1074.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int N, X, cont; 6 | scanf("%d", &N); 7 | for (cont = 1; cont <= N; cont++) 8 | { 9 | scanf("%d", &X); 10 | if (X == 0) 11 | printf("NULL\n"); 12 | else if (X <= 0 && X % 2 == 0) 13 | printf("EVEN NEGATIVE\n"); 14 | else if (X <= 0 && X % 2 == -1) 15 | printf("ODD NEGATIVE\n"); 16 | else if (X >= 0 && X % 2 == 0) 17 | printf("EVEN POSITIVE\n"); 18 | else if (X >= 0 && X % 2 == 1) 19 | printf("ODD POSITIVE\n"); 20 | } 21 | return 0; 22 | } -------------------------------------------------------------------------------- /C/Iniciante/2168/2168.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() 5 | { 6 | int N; 7 | scanf("%d", &N); 8 | int M[N+1][N+1]; 9 | int i, j; 10 | 11 | for (i = 0; i <= N; i++) 12 | { 13 | for (j = 0; j <= N; j++) 14 | { 15 | scanf("%d", &M[i][j]); 16 | } 17 | } 18 | 19 | for (i = 0; i < N; i++) 20 | { 21 | for (j = 0; j < N; j++) 22 | { 23 | if(M[i][j]+M[i][j+1]+M[i+1][j]+M[i+1][j+1] < 2) 24 | printf("U"); 25 | else 26 | printf("S"); 27 | } 28 | printf("\n"); 29 | } 30 | 31 | 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /C/Iniciante/2846/2846.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int a, b, fibo, k, vetor[1000000], aux, i; 6 | 7 | scanf("%d", &k); 8 | 9 | a = 2; 10 | b = 3; 11 | i = 0; 12 | 13 | while (i <= k-1) { 14 | fibo = a + b; 15 | a = b; 16 | b = fibo; 17 | 18 | if (b - a > 1) { 19 | aux = a + 1; 20 | while (aux < b) { 21 | vetor[i] = aux; 22 | aux++; 23 | i++; 24 | } 25 | } 26 | } 27 | 28 | printf("%d\n", vetor[k-1]); 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /C/Iniciante/1099/1099.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | 6 | int X, Y, N, aux, soma = 0; 7 | 8 | scanf("%d", &N); 9 | 10 | for (int i = 0; i < N; i++) { 11 | 12 | scanf("%d %d", &X, &Y); 13 | 14 | if (X > Y) { 15 | aux = X; 16 | X = Y; 17 | Y = aux; 18 | } 19 | 20 | soma = 0; 21 | 22 | for (X++; X < Y; X++) { 23 | if (X % 2 == 1) { 24 | soma = soma + X; 25 | } 26 | } 27 | 28 | printf("%d\n", soma); 29 | } 30 | 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /C/Iniciante/3039/3039.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | 6 | int n, i, carrinho, boneca; 7 | char *nome = (char*) malloc(sizeof(char)); 8 | char genero; 9 | 10 | carrinho = 0; 11 | boneca = 0; 12 | 13 | scanf ("%d",&n); 14 | 15 | for (i=0;i 2 | 3 | int main() { 4 | int alcool, gasolina, diesel, entrada; 5 | alcool = 0; 6 | gasolina = 0; 7 | diesel = 0; 8 | 9 | do { 10 | scanf("%d", &entrada); 11 | 12 | if(entrada == 1) 13 | alcool++; 14 | else if(entrada == 2) 15 | gasolina++; 16 | else if(entrada == 3) 17 | diesel++; 18 | } 19 | while(entrada != 4); 20 | 21 | printf("MUITO OBRIGADO\n"); 22 | printf("Alcool: %d\n", alcool); 23 | printf("Gasolina: %d\n", gasolina); 24 | printf("Diesel: %d\n", diesel); 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /Python/Iniciante/1010.py: -------------------------------------------------------------------------------- 1 | # Problema 1010 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Como todos os valores estão na mesma linha 4 | # Lemos a linha com o 'input' 5 | # Dividimos os valores com 'split' 6 | # Convertemos os valores com 'map' e 'float' 7 | # Como são três valores, cada variável recebera um 8 | codigoA, quantidadeA, valorA = map(float, input().split()) 9 | codigoB, quantidadeB, valorB = map(float, input().split()) 10 | 11 | # Então calculamos o custo 12 | custoA = quantidadeA * valorA 13 | custoB = quantidadeB * valorB 14 | 15 | # E printamos o valor formatado, com duas casas decimais 16 | print(f'VALOR A PAGAR: R$ {(custoA + custoB):.2f}') -------------------------------------------------------------------------------- /Python/Iniciante/1178.py: -------------------------------------------------------------------------------- 1 | #Problema 1178 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Leitura do valor de x 4 | x = float(input()) 5 | 6 | #Colocando o primeiro valor no vetor 7 | N = [x] 8 | 9 | #Mostrando o primeiro valor do vetor 10 | print(f"N[0] = {N[0]:.4f}") 11 | 12 | #Criação de um loop que preencherá o vetor com os 99 elementos restantes 13 | for i in range(1,100): 14 | 15 | #Divisão do valor de x por dois para que o próximo elementa de N receba metade do valor atual de x 16 | x = x/2 17 | #Acréscimo do valor de x no final o vetor N 18 | N.append(x) 19 | #Printando os valores do vetor. 20 | print(f"N[{i}] = {N[i]:.4f}") -------------------------------------------------------------------------------- /Python/Iniciante/3170.py: -------------------------------------------------------------------------------- 1 | # Problema 3170 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Ler quantidade bolinhas e de galhos 4 | bolinhas_quantidade = int(input()) 5 | galhos_quantidade = int(input()) 6 | 7 | # Arredondando par baixo 8 | if(galhos_quantidade % 2 != 0): 9 | galhos_quantidade = galhos_quantidade - 1 10 | 11 | # Conferindo se as bolinha são suficiente e imprimindo a resposta 12 | if(galhos_quantidade <= bolinhas_quantidade * 2): 13 | print("Amelia tem todas bolinhas!") 14 | else: 15 | # Cálculo de bolinhas que faltam 16 | resto = (galhos_quantidade - (2*bolinhas_quantidade)) / 2 17 | print(f'Faltam {resto:.0f} bolinha(s)') 18 | -------------------------------------------------------------------------------- /Python/Strings/2150.py: -------------------------------------------------------------------------------- 1 | # Problema 2150 - Beecrowd - String - Nível 4 2 | 3 | # Leitura até o fim do arquivo 4 | while True: 5 | try: 6 | # Leitura das vogais alienígenas 7 | vogais = input() 8 | 9 | # Leitura da frase 10 | frase = input() 11 | 12 | # Iniciando o contador 13 | total = 0 14 | 15 | # Contando as ocorrências 16 | for letra in vogais: 17 | total += frase.count(letra) 18 | 19 | # Imprimindo o resultado 20 | print(total) 21 | 22 | # Caso chegue no fim do arquivo (EOF), o loop para 23 | except EOFError: 24 | break 25 | -------------------------------------------------------------------------------- /C/Strings/1607/1607.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int T; 6 | 7 | scanf("%d", &T); 8 | 9 | while (T) { 10 | char stringA[10001], *p1; 11 | char stringB[10001], *p2; 12 | int operacoes = 0; 13 | 14 | scanf("%s%s", stringA, stringB); 15 | 16 | for (p1 = stringA, p2 = stringB; *p1 != '\0'; ++p1, ++p2) { 17 | if (*p2 >= *p1) 18 | operacoes += *p2 - *p1; 19 | else 20 | operacoes += ('z' - *p1) + (*p2 - 'a') + 1; 21 | } 22 | 23 | printf("%d\n", operacoes); 24 | 25 | --T; 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Python/Iniciante/1018.py: -------------------------------------------------------------------------------- 1 | # Problema 1018 - Beecrowd - Iniciante - Nível 4 2 | 3 | # Vamos ler o valor e converter para inteiro 4 | valor = int(input()) 5 | 6 | # Vamos usar um vetor com os valores das notas 7 | notas = [100, 50, 20, 10, 5, 2, 1] 8 | 9 | # O problema requer o valor na resposta 10 | print(valor) 11 | 12 | # Vamos fazer um loop para calcular a quantidade de cada nota 13 | for nota in notas: 14 | # Vamos ver quantas notas desse valor cabem no valor 15 | quantidade = valor//nota 16 | # O resto passa a ser o novo valor 17 | valor = valor%nota 18 | # Então printamos a quantidade de notas 19 | print(f'{quantidade} nota(s) de R$ {nota},00') -------------------------------------------------------------------------------- /Python/Iniciante/1164.py: -------------------------------------------------------------------------------- 1 | # Problema 1164 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Leitura do número de casos de teste 4 | N = int(input()) 5 | 6 | # Loop para verificar os casos de teste 7 | for _ in range(N): 8 | # Leitura de um valor inteiro a ser julgado 9 | X = int(input()) 10 | 11 | # Soma dos divisores 12 | soma = 0 13 | 14 | # Cálculo da soma dos divisores 15 | for i in range(1, X): 16 | if X % i == 0: 17 | soma += i 18 | 19 | # Verificando se X é perfeito, ou não 20 | if soma == X: 21 | print(f'{X} eh perfeito') 22 | else: 23 | print(f'{X} nao eh perfeito') 24 | -------------------------------------------------------------------------------- /C/Iniciante/1983/1983.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N, i, matricula, matriculaMaior; 5 | float nota, notaMaior; 6 | 7 | scanf("%d",&N); 8 | 9 | scanf("%d %f", &matriculaMaior, ¬aMaior); 10 | 11 | for (i = 1; i < N; i++) { 12 | scanf("%d %f", &matricula, ¬a); 13 | 14 | if (nota > notaMaior) { 15 | matriculaMaior = matricula; 16 | notaMaior = nota; 17 | } 18 | } 19 | 20 | if (notaMaior >= 8) { 21 | printf("%d\n", matriculaMaior); 22 | } 23 | 24 | else { 25 | printf("Minimum note not reached\n"); 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Python/Iniciante/1036.py: -------------------------------------------------------------------------------- 1 | # Problema 1036 - Beecrowd - Iniciante - Nível 3 2 | 3 | # Importa o módulo com funções matemáticas básicas 4 | import math 5 | 6 | # Leitura dos valores 7 | A, B, C = map(float, input().split()) 8 | 9 | # Verifica se existe raiz real para essa equação 10 | if (pow(B, 2) - 4*A*C) > 0 and A != 0: 11 | # Cálculo das raízes 12 | R1 = (-B + math.sqrt(pow(B, 2) - 4*A*C))/(2*A) 13 | R2 = (-B - math.sqrt(pow(B, 2) - 4*A*C))/(2*A) 14 | 15 | # Imprime as raízes na saída padrão 16 | print(f"R1 = {R1:.5f}") 17 | print(f"R2 = {R2:.5f}") 18 | else: 19 | # Caso não exista raíz real 20 | print("Impossivel calcular") 21 | -------------------------------------------------------------------------------- /C/Iniciante/1160/1160.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int contador, T, PA, PB, anos; 5 | double G1, G2; 6 | 7 | scanf("%d", &T); 8 | 9 | for(contador=0; contador 100){ 21 | printf("Mais de 1 seculo.\n"); 22 | break; 23 | } 24 | } 25 | 26 | if (anos <= 100) 27 | printf("%d anos.\n", anos); 28 | } 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /C/Iniciante/1914/1914.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int QT; 5 | long long num, num2; 6 | char jogador[100], jogador2[100], escolha[6], resultado; 7 | 8 | scanf("%d", &QT); 9 | 10 | while (QT--) { 11 | scanf("%s", jogador); 12 | scanf("%s", escolha); 13 | scanf("%s", jogador2); 14 | scanf("%s", escolha); 15 | scanf("%lld %lld", &num, &num2); 16 | 17 | if (num % 2 == num2 % 2) resultado = 'P'; 18 | else resultado = 'I'; 19 | 20 | if (escolha[0] == resultado) printf("%s\n", jogador2); 21 | else printf("%s\n", jogador); 22 | } 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /Python/Iniciante/1858.py: -------------------------------------------------------------------------------- 1 | # Problema 1858 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Não necessitamos da primeira entrada, que refere-se à quantidade 4 | # de pessoas. Utilizamos '_' para sinalizar isso. 5 | _ = int(input()) 6 | 7 | # Recebendo os inteiros que representam a quantidade de punições recebidas por Theon ao escolher uma determinada pessoa 8 | consequencias = [int(x) for x in input().split()] 9 | 10 | # Recebendo o índice do elemento de menor valor da lista de consequências 11 | # Adiciona-se 1 já que o índice da lista inicia em 0 12 | minimo = consequencias.index(min(consequencias)) + 1 13 | 14 | # Imprimindo na tela o valor mínimo 15 | print(minimo) 16 | -------------------------------------------------------------------------------- /Python/Iniciante/1871.py: -------------------------------------------------------------------------------- 1 | # Problema 1871 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Laço de repetição infinito para executar todos os casos de teste até a função quit() ser chamada 4 | while True: 5 | 6 | # Leitura das variávies iniciais 7 | x, y = map(int,input().split()) 8 | 9 | # Condição de parada caso ambas as variáveis forem nulas 10 | if x==0 and y==0: 11 | quit() 12 | 13 | # Soma 14 | soma = x+y 15 | 16 | # Transformando a soma em uma string e substituindo os caracteres 0 por caracteres nulos 17 | soma=int(str(soma).replace('0','')) 18 | 19 | # Imprimindo a soma sem zeros 20 | print(f'{soma}') 21 | 22 | 23 | -------------------------------------------------------------------------------- /C/Strings/2132/2132.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | 8 | char palavra[61]; 9 | int i, tam, caso = 1; 10 | long long int total; 11 | 12 | while (scanf("%s", palavra) != EOF) 13 | { 14 | printf("Palavra %i\n", caso); 15 | tam = strlen(palavra); 16 | total = 0; 17 | 18 | for (i = 0; i < tam; i++) 19 | { 20 | if (palavra[i] == 'b') 21 | { 22 | total = total + pow(2, tam - i - 1); 23 | } 24 | } 25 | 26 | printf("%lld\n\n", total); 27 | caso++; 28 | } 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /Python/Strings/1257.py: -------------------------------------------------------------------------------- 1 | # Problema 1257 - Beecrowd - String - Nível 3 2 | 3 | # Número de casos de teste 4 | n = int(input()) 5 | 6 | # Para cada caso de teste 7 | for _ in range(n): 8 | # Lemos o número de linhas 9 | l = int(input()) 10 | 11 | # Valor da hash 12 | h = 0 13 | 14 | # Para cada linha 15 | for elemento in range(l): 16 | # Lemos a linha 17 | linha = input() 18 | 19 | # Para cada caractere da linha 20 | for posição, c in enumerate(linha): 21 | # Somamos à hash 22 | # O valor do caractere 23 | # O índice do elemento 24 | # A posição 25 | h += (ord(c) - 65) + elemento + posição 26 | 27 | # Printamos o valor da hash 28 | print(h) 29 | -------------------------------------------------------------------------------- /C/Iniciante/2702/2702.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main (){ 4 | 5 | int frangoDisp, bifeDisp, massaDisp; 6 | int frangoReq, bifeReq, massaReq; 7 | int resFrango, resBife, resMassa; 8 | 9 | scanf("%d %d %d", &frangoDisp, &bifeDisp, &massaDisp); 10 | scanf("%d %d %d", &frangoReq, &bifeReq, &massaReq); 11 | 12 | resFrango = frangoDisp - frangoReq; 13 | 14 | if (resFrango > 0) 15 | resFrango = 0; 16 | 17 | 18 | resBife = bifeDisp - bifeReq; 19 | if (resBife > 0) 20 | resBife = 0; 21 | 22 | 23 | resMassa = massaDisp - massaReq; 24 | if (resMassa > 0) 25 | resMassa = 0; 26 | 27 | printf("%d\n", -(resFrango + resBife + resMassa)); 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /C/Strings/1274/1274.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | 6 | char pomedex[151][1001], pomekon[1001]; 7 | int i, n, topo, quant; 8 | 9 | topo = -1; 10 | quant = 1; 11 | 12 | scanf("%d", &n); 13 | 14 | while(n--){ 15 | 16 | scanf("%s", pomekon); 17 | 18 | if(topo == -1) 19 | strcpy(pomedex[++topo], pomekon); 20 | 21 | else{ 22 | 23 | i=0; 24 | 25 | while(i <= topo && strcmp(pomedex[i],pomekon)) 26 | i++; 27 | 28 | if(i>topo){ 29 | strcpy(pomedex[++topo], pomekon); 30 | quant++; 31 | } 32 | } 33 | } 34 | 35 | printf("Falta(m) %d pomekon(s).\n", 151 - quant); 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Python/Strings/3141.py: -------------------------------------------------------------------------------- 1 | # Problema 3141 - Beecrowd - Strings - Nível 5 2 | 3 | # Leitura dos valores 4 | nome = input() 5 | dia_atual, mes_atual, ano_atual = map(int, input().split('/')) 6 | dia_aniv, mes_aniv, ano_aniv = map(int, input().split('/')) 7 | 8 | # Checagem de aniversário 9 | if dia_aniv == dia_atual and mes_aniv == mes_atual: 10 | print("Feliz aniversario!") 11 | 12 | # Calculando idade 13 | # Primeiro verificar se no ano atual já fez aniversário 14 | if mes_aniv < mes_atual or (mes_atual == mes_aniv and dia_aniv <= dia_atual): 15 | idade = ano_atual - ano_aniv 16 | else: 17 | idade = ano_atual - ano_aniv - 1 18 | 19 | print(f"Voce tem {idade} anos {nome}.") -------------------------------------------------------------------------------- /C/Iniciante/1183/1183.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | double soma = 0.0, M[12][12]; 5 | char O[2]; 6 | int coluna, x, y, linha, contagem = 1; 7 | scanf("%s", &O); 8 | for (x = 0; x <= 11; x++) 9 | { 10 | for (y = 0; y <= 11; y++) 11 | scanf("%lf", &M[x][y]); 12 | } 13 | for (linha = 0; linha <= 11; linha++) 14 | { 15 | for (coluna = contagem; coluna <= 11; coluna++) 16 | soma += M[linha][coluna]; 17 | contagem++; 18 | } 19 | if (O[0] == 'S') 20 | printf("%.1lf\n", soma); 21 | else 22 | { 23 | printf("%.1lf\n", soma / 66.0); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /C/Iniciante/2774/2774.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | 6 | int H, M, QT, i; 7 | double X[1000000], xMedio, soma, somatorio, sigma; 8 | 9 | while (scanf("%d %d", &H, &M) != EOF) { 10 | 11 | QT = (int)(H*60)/M; 12 | soma = 0; 13 | somatorio = 0; 14 | 15 | for(i = 0; i < QT; i++) { 16 | scanf("%lf", &X[i]); 17 | soma += X[i]; 18 | } 19 | 20 | xMedio = soma / QT; 21 | 22 | for(i = 0; i < QT; i++) { 23 | soma = (X[i]-xMedio); 24 | soma *= soma; 25 | somatorio += soma; 26 | } 27 | 28 | sigma = sqrt((somatorio / (QT-1))); 29 | printf("%.5lf\n", sigma); 30 | } 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /C/Strings/1253/1253.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | int i, deslocamento = 0, casos = 0, aux = 0; 7 | char cifra[50]; 8 | scanf("%d", &casos); 9 | while(casos--){ 10 | scanf("%s", cifra); 11 | scanf("%d", &deslocamento); 12 | for (i = 0; i < 50; i++){ 13 | if (cifra[i] == '\0') 14 | break; 15 | if ((cifra[i] - deslocamento) < 65) 16 | aux = (cifra[i] - deslocamento) + 26; 17 | else 18 | aux = cifra[i] - deslocamento; 19 | printf("%c", aux); 20 | } 21 | printf("\n"); 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /Python/Strings/1248.py: -------------------------------------------------------------------------------- 1 | # Problema 1248 - Beecrowd - String - Nível 2 2 | 3 | # Número de casos de teste 4 | n = int(input()) 5 | 6 | # Para cada caso 7 | for _ in range(n): 8 | # Criamos um conjunto a partir de cada entrada 9 | dieta = set(input()) 10 | café = set(input()) 11 | almoço = set(input()) 12 | 13 | # Fazemos as operações que nos convém com os conjuntos 14 | comeu = café | almoço 15 | extra = comeu - dieta 16 | faltou = dieta - comeu 17 | 18 | # Verificamos se algo extra foi comido 19 | if extra != set(): 20 | # Se sim, mostramos 'CHEATER' 21 | print('CHEATER') 22 | else: 23 | # Se não, mostramos o que faltou 24 | print(''.join(sorted(faltou))) 25 | -------------------------------------------------------------------------------- /Python/Strings/2591.py: -------------------------------------------------------------------------------- 1 | # Problema 2591 - Beecrowd - String - Nível 1 2 | 3 | # Lendo a quantidade de testes 4 | n = int(input()) 5 | 6 | # Percorrendo os testes 7 | for i in range(n): 8 | # Lendo o hamekame e dividindo no meio 'mek' 9 | hamekame = input().split('mek') 10 | 11 | # Separando em variáveis para ficar mais facil entender 12 | ha = hamekame[0] 13 | ame = hamekame[1] 14 | 15 | # A quantidade de 'a' da finalização é a quantidade 16 | # de 'a' na variável 'ha' vezes a quantidade de 'a' na variável 'ame'. 17 | aaa = ha.count('a') * ame.count('a') 18 | 19 | # Em python podemos multiplicar uma string por um número 20 | print('k' + 'a'*aaa) -------------------------------------------------------------------------------- /C/Iniciante/2533/2533.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int M, N[40], C[40], i; 6 | double resultado, cima, baixo; 7 | 8 | 9 | while(scanf("%d",&M) != EOF ) { 10 | 11 | 12 | for ( i=0; i tB: 26 | break 27 | 28 | if r == 0: 29 | print("Impossibilidade de empate.") 30 | else: 31 | print(input()) 32 | -------------------------------------------------------------------------------- /C/Iniciante/1185/1185.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | double soma = 0.0, M[12][12]; 5 | char O; 6 | int coluna, linha, contagem = 10; 7 | scanf("%s", &O); 8 | for (linha = 0; linha <= 11; linha++) 9 | { 10 | for (coluna = 0; coluna <= 11; coluna++) 11 | scanf("%lf", &M[linha][coluna]); 12 | } 13 | for (linha = 0; linha <= 10; linha++) 14 | { 15 | for (coluna = 0; coluna <= contagem; coluna++) 16 | soma += M[linha][coluna]; 17 | contagem--; 18 | } 19 | if (O == 'S') 20 | printf("%.1lf\n", soma); 21 | else 22 | { 23 | printf("%.1lf\n", soma / 66.0); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /C/Iniciante/1187/1187.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | double total, M[12][12]; 4 | char O; 5 | int i, j; 6 | 7 | total = 0; 8 | 9 | scanf("%c", &O); 10 | 11 | for (i = 0; i < 12; i++) { 12 | for (j = 0; j < 12; j++) { 13 | scanf("%lf", &M[i][j]); 14 | } 15 | } 16 | 17 | for (i = 0; i < 5; i++) { 18 | for (j = (i + 1); j <= (10 - i); j++) { 19 | total += M[i][j]; 20 | } 21 | } 22 | 23 | if (O == 'S') { 24 | printf("%.1lf\n", total); 25 | } 26 | 27 | else if (O == 'M') { 28 | total = total / 30.0; 29 | printf("%.1lf\n", total); 30 | } 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /C/Iniciante/1184/1184.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | double soma = 0.0, M[12][12]; 5 | char O; 6 | int coluna, linha, contagem = 0; 7 | scanf("%s", &O); 8 | for (linha = 0; linha <= 11; linha++) 9 | { 10 | for (coluna = 0; coluna <= 11; coluna++) 11 | scanf("%lf", &M[linha][coluna]); 12 | } 13 | for (linha = 1; linha <= 11; linha++) 14 | { 15 | for (coluna = 0; coluna <= contagem; coluna++) 16 | soma += M[linha][coluna]; 17 | contagem++; 18 | } 19 | if (O == 'S') 20 | printf("%.1lf\n", soma); 21 | else 22 | { 23 | printf("%.1lf\n", soma / 66.0); 24 | } 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /C/Iniciante/1186/1186.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | double soma = 0.0, M[12][12]; 5 | char O; 6 | int coluna, linha, contagem = 11; 7 | scanf("%s", &O); 8 | for (linha = 0; linha <= 11; linha++) 9 | { 10 | for (coluna = 0; coluna <= 11; coluna++) 11 | scanf("%lf", &M[linha][coluna]); 12 | } 13 | for (linha = 1; linha <= 11; linha++) 14 | { 15 | for (coluna = 11; coluna >= contagem; coluna--) 16 | soma += M[linha][coluna]; 17 | contagem--; 18 | } 19 | if (O == 'S') 20 | printf("%.1lf\n", soma); 21 | else 22 | { 23 | printf("%.1lf\n", soma / 66.0); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /C/Strings/3038/3038.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | int i; 6 | char texto[300]; 7 | 8 | while (~scanf("%[^\n]%*c", texto)){ 9 | for (i = 0; i < strlen(texto); i++){ 10 | if (texto[i] == '@') 11 | texto[i] = 'a'; 12 | else if (texto[i] == '&') 13 | texto[i] = 'e'; 14 | else if (texto[i] == '!') 15 | texto[i] = 'i'; 16 | else if (texto[i] == '*') 17 | texto[i] = 'o'; 18 | else if (texto[i] == '#') 19 | texto[i] = 'u'; 20 | } 21 | 22 | for (i = 0; i < strlen(texto); i++){ 23 | printf("%c", texto[i]); 24 | } 25 | 26 | printf("\n"); 27 | } 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /C/Strings/3088/3088.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() 5 | { 6 | 7 | char string[1000]; 8 | int i = 0; 9 | while (~scanf("%[^\n]%*c", string)) 10 | { 11 | 12 | i = 0; 13 | while (string[i]) 14 | { 15 | 16 | if (string[i] == ' ') 17 | if (string[i + 1] == ',' || string[i + 1] == '.') 18 | putchar_unlocked(string[i + 1]), ++i; 19 | else 20 | putchar_unlocked(string[i]); 21 | else 22 | putchar_unlocked(string[i]); 23 | 24 | ++i; 25 | 26 | } 27 | 28 | putchar_unlocked('\n'); 29 | 30 | } 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /Python/Iniciante/1038.py: -------------------------------------------------------------------------------- 1 | # Problema 1038 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Entrada de dados com a função split e map para dividir os valores de entrada pelo 'espaço' e converte-los para float, respectivamente 4 | item, qtd_item = map(float, input().split(' ')) 5 | 6 | # Estrutura condicional para escolher qual será o preço total cobrado. 7 | if (item == 1): 8 | preco_total = 4.00*qtd_item 9 | elif (item == 2): 10 | preco_total = 4.50*qtd_item 11 | elif (item == 3): 12 | preco_total = 5.00*qtd_item 13 | elif (item == 4): 14 | preco_total = 2.00*qtd_item 15 | elif (item == 5): 16 | preco_total = 1.50*qtd_item 17 | 18 | # Saída de dados 19 | print(f"Total: R$ {preco_total:.2f}") 20 | -------------------------------------------------------------------------------- /Python/Iniciante/1115.py: -------------------------------------------------------------------------------- 1 | # Problema 1115 - Beecrowd - Iniciante - Nível 1 2 | 3 | while True: 4 | x, y = map(int, input().split(' ')) 5 | # Se os sinais forem iguais e 6 | if x*y > 0: 7 | # Se ambos forem positivos, a resposta será o primeiro quadrante 8 | # Senão, a resposta será o terceiro quadrante 9 | print("primeiro" if x > 0 else "terceiro") 10 | # se os sinais forem diferentes e 11 | elif x*y < 0: 12 | # Se o x for positivo, a resposta será o quarto quadrante 13 | # Senão, a resposta será o segundo quadrante 14 | print("quarto" if x > 0 else "segundo") 15 | # Se algum for nulo, o programa termina 16 | else: 17 | break 18 | -------------------------------------------------------------------------------- /Python/Iniciante/1158.py: -------------------------------------------------------------------------------- 1 | # Problema 1158 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Lendo o valor de entrada inteiro 4 | entrada = int(input()) 5 | # Loop dos testes 6 | for i in range(entrada): 7 | # Lendo X e Y 8 | X, Y = map(int, input().split(" ")) 9 | # Variável auxiliar e soma 10 | j = 0 11 | soma = 0 12 | # Loop para checagem de ímpares 13 | while j < Y: 14 | # Conferindo de o valor em X é ímpar 15 | if(X % 2 == 1): 16 | # Somando o valor de X a soma e incrementando o contador 17 | soma += X 18 | j += 1 19 | # Incremetando o valor de X para prosseguir para o próximo valor ímpar 20 | X += 1 21 | # Imprimindo a soma final 22 | print(soma) 23 | 24 | -------------------------------------------------------------------------------- /Python/Strings/2880.py: -------------------------------------------------------------------------------- 1 | mensagem = input() 2 | crib = input() 3 | crib_tam = len(crib) 4 | possiveis_posicoes = 0 5 | 6 | #o iterador percorrerá a mensagem enquanto houver espaço para a crib 7 | for i in range(len(mensagem) - len(crib) + 1): 8 | igual = False 9 | j = 0 10 | #enquanto não achar uma letra igual, percorre a substring 11 | #da mensagem que tem o mesmo tamanho de crib 12 | while not igual and j < crib_tam: 13 | if mensagem[i + j] == crib[j]: 14 | igual = True 15 | j += 1 16 | #se não encontrou nenhum caracter igual, é uma possivel posição 17 | if not igual: 18 | possiveis_posicoes += 1 19 | 20 | print(possiveis_posicoes) 21 | -------------------------------------------------------------------------------- /C/Iniciante/1151/1151.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int i, aux1, aux2, N, x; 6 | aux1 = 0; 7 | aux2 = 1; 8 | 9 | scanf("%d", &N); 10 | 11 | switch (N) { 12 | case 1: 13 | printf("0\n"); 14 | break; 15 | case 2: 16 | printf("0 1\n"); 17 | break; 18 | default: 19 | printf("0 1 "); 20 | for (i=2;i 2 | 3 | int main() 4 | { 5 | int N, i, L; 6 | int mult2 = 0, mult3 = 0, mult4 = 0, mult5 = 0; 7 | 8 | scanf("%d", &N); 9 | 10 | for (i = 0; i < N; i++) 11 | { 12 | scanf("%d", &L); 13 | if(L%2==0){ 14 | mult2++; 15 | } 16 | if(L%3==0){ 17 | mult3++; 18 | } 19 | if(L%4==0){ 20 | mult4++; 21 | } 22 | if(L%5==0){ 23 | mult5++; 24 | } 25 | } 26 | printf("%d Multiplo(s) de 2\n", mult2); 27 | printf("%d Multiplo(s) de 3\n", mult3); 28 | printf("%d Multiplo(s) de 4\n", mult4); 29 | printf("%d Multiplo(s) de 5\n", mult5); 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /Python/Iniciante/1159.py: -------------------------------------------------------------------------------- 1 | # Problema 1159 - Beecrowd - Iniciante - Nível 1 2 | 3 | while True: 4 | x = int(input()) 5 | y = x 6 | i = 0 7 | soma = 0 8 | #Ponto de parada requisitado pelo exercício 9 | if(x == 0): 10 | break 11 | #Verificando se o número é par, e caso sim, fazendo a soma dele com seus 4 pares seguintes 12 | if(x % 2 == 0): 13 | for i in range(5): 14 | soma = soma + y 15 | y = y + 2 16 | #Caso o número seja ímpar, ele é incrementado para virar par e é somado com os 4 pares seguintes 17 | else: 18 | y = y + 1 19 | for i in range(5): 20 | soma = soma + y 21 | y = y + 2 22 | print(soma) 23 | -------------------------------------------------------------------------------- /Python/Strings/2691.py: -------------------------------------------------------------------------------- 1 | # Problema 2691- Beecrowd - Strings - Nível 3 2 | 3 | # Quantas vezes o programa será testado - N, o primeiro input 4 | for _ in range(int(input())): 5 | 6 | # Para cada teste, separamos os fatores da multiplicação pelo 'x' 7 | # E convertemos para números inteiros com o map (Já que .split devolve uma lista) 8 | # Colocamos os dois números em X e Y 9 | X, Y = map(int, input().split('x')) 10 | 11 | # Se X for igual a Y não precisamos imprimir para X e para Y 12 | if X == Y: 13 | for i in range(5,11): 14 | print(f"{X} x {i} = {X*i}") 15 | else: 16 | for i in range(5,11): 17 | print(f"{X} x {i} = {X*i} && {Y} x {i} = {Y*i}") 18 | -------------------------------------------------------------------------------- /C/Strings/1632/1632.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void main () { 5 | 6 | int possibilidades; 7 | int T; 8 | int i, j; 9 | char senha[20]; 10 | 11 | scanf("%d", &T); 12 | 13 | for (j = 0; j < T; j++){ 14 | 15 | scanf(" %s", senha); 16 | possibilidades = 1; 17 | 18 | for (i = 0; senha[i]; i++){ 19 | if (tolower(senha[i]) == 'a' || tolower(senha[i]) == 'e' || tolower(senha[i]) == 'i' || tolower(senha[i]) == 'o' || tolower(senha[i]) == 's') 20 | possibilidades *= 3; 21 | else 22 | possibilidades *= 2; 23 | } 24 | 25 | printf("%d\n", possibilidades); 26 | 27 | } 28 | 29 | } -------------------------------------------------------------------------------- /C/Iniciante/1929/1929.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | int A, B, C, D, v[4], i, j, aux; 6 | 7 | scanf("%d%d%d%d", &A, &B, &C, &D); 8 | 9 | v[0] = A; 10 | v[1] = B; 11 | v[2] = C; 12 | v[3] = D; 13 | 14 | for(j=0;j<4;j++) 15 | for(i=0;i<3;i++) { 16 | if (v[i] > v[i+1]) { 17 | aux = v[i+1]; 18 | v[i+1] = v[i]; 19 | v[i] = aux; 20 | } 21 | } 22 | 23 | if ((((v[0] + v[1]) > v[3]) || ((v[0] + v[2]) > v[3])) || (((v[1] + v[2]) > v[3]) || ((v[0] + v[1]) > v[2]))) 24 | printf("S\n"); 25 | else 26 | printf("N\n"); 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /Python/Iniciante/2896.py: -------------------------------------------------------------------------------- 1 | # Problema 2896 - Beecrowd - Iniciante - Nível 1 2 | 3 | # Recebe a quantidade de casos teste 4 | T = int(input()) 5 | 6 | # Laço de repetição que irá executar o loop 7 | # 3 vezes, recebendo a quantidade de garrafas 8 | # compradas e quantidade de garrafas vazias 9 | # para poder usufruir da promoção 10 | for i in range(T): 11 | N, K = [int(i) for i in input().split()] 12 | 13 | # Imprime o resto da divisão de N por K 14 | # que indica a quantia de garrafas que sobram; 15 | # somando-se o valor da quantidade de garrafas 16 | # que efetivamente ativam a promoção dividido pelo 17 | # número de garrafas necessárias para ganhar uma garrafa 18 | print(int(N % K + (N - N % K)/K)) 19 | -------------------------------------------------------------------------------- /C/Iniciante/2311/2311.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int N, i, j; 6 | char nome[20]; 7 | double GD, pontuacao, max = 0.00, min = 10.00, soma = 0.00; 8 | scanf("%d", &N); 9 | for(i=1; i<=N; i++) 10 | { 11 | scanf("%s", nome); 12 | scanf("%lf", &GD); 13 | for(j=1; j<=7; j++) 14 | { 15 | scanf("%lf", &pontuacao); 16 | if(pontuacao > max) max = pontuacao; 17 | if(pontuacao < min) min = pontuacao; 18 | soma += pontuacao; 19 | } 20 | soma -= (max+min); 21 | soma *= GD; 22 | printf("%s %.2lf\n", nome, soma); 23 | max = 0.00, min = 10.00, soma = 0.00; 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /C/Iniciante/1961/1961.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int alturaPulo, nroCanos, i; 5 | int diffAlturas, ehGameOver = 0; 6 | 7 | scanf("%d %d", &alturaPulo, &nroCanos); 8 | 9 | int alturaCanos[nroCanos]; 10 | 11 | for (i=0; i alturaPulo){ 19 | ehGameOver = 1; 20 | break; 21 | } 22 | } 23 | 24 | if(ehGameOver == 0) 25 | printf("YOU WIN\n"); 26 | else 27 | printf("GAME OVER\n"); 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /C/Iniciante/2715/2715.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | long long int N, X[1000000], somaGugu, somaRangel, i, j; 6 | 7 | while(scanf("%lld", &N) != EOF){ 8 | 9 | for(i = 0; i < N; i++){ 10 | scanf("%lld", &X[i]); 11 | } 12 | 13 | i = 0; 14 | j = N-1; 15 | somaGugu = 0; 16 | somaRangel = 0; 17 | 18 | while(i<=j){ 19 | 20 | if((somaRangel + X[i]) <= (somaGugu + X[j])){ 21 | 22 | somaRangel += X[i]; 23 | i++; 24 | } 25 | 26 | else{ 27 | somaGugu += X[j]; 28 | j--; 29 | 30 | } 31 | } 32 | 33 | if(somaRangel >= somaGugu) 34 | printf("%lld\n", somaRangel - somaGugu); 35 | 36 | else 37 | printf("%lld\n", somaGugu - somaRangel); 38 | } 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /C/Strings/2049/2049.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int contem_assinatura(char *, char *); 6 | 7 | int main(){ 8 | int instancia=1; 9 | bool i=true; 10 | char a[10], b[300001]; 11 | 12 | while(i){ 13 | scanf("%s", a); 14 | 15 | if(strcmp(a, "0") != 0){ 16 | if(instancia != 1) 17 | printf("\n"); 18 | 19 | scanf("%s", b); 20 | printf("Instancia %d\n", instancia++); 21 | if(contem_assinatura(a, b)){ 22 | printf("verdadeira\n"); 23 | } 24 | else 25 | printf("falsa\n"); 26 | } else{ 27 | i=false; 28 | } 29 | } 30 | return 0; 31 | } 32 | 33 | int contem_assinatura(char *a, char *b){ 34 | if(strstr(b, a)) 35 | return 1; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Python/Iniciante/1837.py: -------------------------------------------------------------------------------- 1 | # Problema 1837 - Beecrowd - Iniciante - Nível 7 2 | 3 | # Aqui, teremos que implementar o Algorítmo da Divisão, 4 | # ou 'Teorema da Divisão Euclidiana' 5 | 6 | # Inicialmente, vamos receber os valores de 'a' e 'b' 7 | a, b = map(int, input().split(' ')) 8 | 9 | # Como método de resolução, iremos encontrar um resto 'r' 10 | # da divisão de 'a' pelo valor absoluto de 'b'. 11 | r = a % abs(b) 12 | 13 | # Tendo o resto em mãos, é possível achar o quociente pela 14 | # Teorema da Divisão Euclidiana dado por: a = b * q + r, 15 | # isolando o 'q', temos que: 16 | q = (a - r) / b 17 | 18 | # É impresso o quociente 'q' como um inteiro, pois durante 19 | # a divisão, ele assume o tipo 'float' e o resto 'r'. 20 | print(int(q), r) -------------------------------------------------------------------------------- /C/Iniciante/1050/1050.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int ddd; 5 | scanf("%d", &ddd); 6 | 7 | switch (ddd){ 8 | case 61: 9 | printf("Brasilia\n"); 10 | break; 11 | 12 | case 71: 13 | printf("Salvador\n"); 14 | break; 15 | 16 | case 11: 17 | printf("Sao Paulo\n"); 18 | break; 19 | 20 | case 21: 21 | printf("Rio de Janeiro\n"); 22 | break; 23 | 24 | case 32: 25 | printf("Juiz de Fora\n"); 26 | break; 27 | 28 | case 19: 29 | printf("Campinas\n"); 30 | break; 31 | 32 | case 27: 33 | printf("Vitoria\n"); 34 | break; 35 | 36 | case 31: 37 | printf("Belo Horizonte\n"); 38 | break; 39 | 40 | default: 41 | printf("DDD nao cadastrado\n"); 42 | } 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /C/Iniciante/2534/2534.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void insertionSort(int *vetor, int n) { 4 | int aux, i, j; 5 | for (i=1; i=0) && (vetor[j] 2 | 3 | int main() { 4 | 5 | int h1, m1, h2, m2, th, tm; 6 | scanf("%d%d%d%d", &h1, &m1, &h2, &m2); 7 | 8 | if ((m1 == m2) && (h1 == h2)) { 9 | tm = m2 - m1; 10 | th = 24; 11 | } 12 | 13 | else { 14 | if ((m2 - m1) >= 0) 15 | tm = m2 - m1; 16 | else { 17 | m2 = m2 + 60; 18 | tm = m2 - m1; 19 | h2--; 20 | } 21 | 22 | if ((h2 - h1) >= 0) 23 | th = h2 - h1; 24 | else { 25 | h2 = h2 + 24; 26 | th = h2 - h1; 27 | } 28 | } 29 | printf("O JOGO DUROU %d HORA(S) E %d MINUTO(S)\n", th, tm); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /Python/Strings/2137.py: -------------------------------------------------------------------------------- 1 | while True: 2 | try: 3 | # Leitura do valor N para o caso de teste 4 | valor = int(input()) 5 | # Lista para armazenar os códigos dos livros 6 | numero = [] 7 | 8 | # Loop para ler N códigos dos livros e adicioná-los à lista 9 | for i in range(valor): 10 | # Leitura do código do livro e adição à lista 11 | num = input() 12 | numero.append(num) 13 | 14 | # Ordena a lista de códigos 15 | ordenado = sorted(numero) 16 | 17 | # Imprime os códigos ordenados 18 | for i in range(valor): 19 | print(ordenado[i]) 20 | except EOFError: 21 | # Se ocorrer EOFError, encerra o loop 22 | break 23 | -------------------------------------------------------------------------------- /Python/Iniciante/1046.py: -------------------------------------------------------------------------------- 1 | # Problema 1046 - Beecrowd - Iniciante - Nível 2 2 | 3 | # Recebe a hora de inicio e a hora de finalização do jogo 4 | inicio, fim = map(int, input().split()) 5 | 6 | # Se a hora de inicio for maior que a hora de finalização do jogo, então 7 | # o jogo terminou no dia seguinte ao início, logo: horas úteis no dia do 8 | # início é igual a (24 - inicio), considerando as horas jogadas no dia seguinte 9 | # o tempo total é igual a (24 - inicio + fim). 10 | if inicio >= fim: 11 | print(f"O JOGO DUROU {(24 - inicio + fim)} HORA(S)") 12 | 13 | # Se o jogo começou e terminou no mesmo dia, basta calcular a diferença 14 | # entre a hora da finalização e a hora de inicio. 15 | else: 16 | print(f"O JOGO DUROU {(fim - inicio)} HORA(S)") 17 | -------------------------------------------------------------------------------- /C/Iniciante/1190/1190.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main (){ 4 | double m[12][12], soma, media; 5 | char operacao; 6 | int i, j, cont; 7 | scanf("%c", &operacao); 8 | 9 | for(i = 0; i < 12; i++) 10 | for(j = 0; j < 12; j++) 11 | scanf("%lf", &m[i][j]); 12 | 13 | if (operacao == 'S'){ 14 | soma = 0; 15 | for(i = 0; i < 12; i++) 16 | for(j = 0; j < 12; j++) 17 | if (i < j && i > 12 - j - 1) 18 | soma += m[i][j]; 19 | 20 | printf("%.1lf\n", soma); 21 | } 22 | 23 | if (operacao == 'M'){ 24 | media = 0; 25 | cont = 0; 26 | for(i = 0; i < 12; i++) 27 | for(j = 0; j < 12; j++) 28 | if (i < j && i > 12 - j - 1){ 29 | media += m[i][j]; 30 | cont++; 31 | } 32 | 33 | printf("%.1lf\n", media/cont); 34 | } 35 | } -------------------------------------------------------------------------------- /C/Iniciante/1188/1188.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | double total, M[12][12]; 4 | char O; 5 | int i, j, offset; 6 | 7 | total = 0; 8 | offset = 0; 9 | 10 | scanf("%c", &O); 11 | 12 | for (i = 0; i < 12; i++) { 13 | for (j = 0; j < 12; j++) { 14 | scanf("%lf", &M[i][j]); 15 | } 16 | } 17 | 18 | for (i = 11; i >= 7; i--) { 19 | for (j = (1 + offset); j <= (10 - offset); j++) { 20 | total += M[i][j]; 21 | } 22 | offset++; 23 | } 24 | 25 | if (O == 'S') { 26 | printf("%.1lf\n", total); 27 | } 28 | 29 | else if (O == 'M') { 30 | total = total / 30.0; 31 | printf("%.1lf\n", total); 32 | } 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /C/Iniciante/2140/2140.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int N, M, troco, i, contador; 6 | int possiveis[15] = {7, 12, 22, 52, 102, 15, 25, 55, 105, 30, 60, 110, 70, 120, 150}; 7 | 8 | while(1) 9 | { 10 | scanf("%d%d", &N, &M); 11 | 12 | if(N==0 && M==0) 13 | break; 14 | 15 | troco = M - N; 16 | 17 | for(i=0, contador = 0; i<15; i++) 18 | { 19 | if(possiveis[i] == troco) 20 | { 21 | contador = 1; 22 | break; 23 | } 24 | } 25 | if(contador) 26 | printf("possible\n"); 27 | else 28 | printf("impossible\n"); 29 | } 30 | return 0; 31 | } -------------------------------------------------------------------------------- /C/Strings/2714/2714.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int quantidade_ra, i, j, k; 5 | char ra_enviados[100] = {'0'}, senha_provisoria[20] = {'0'}; 6 | scanf("%d", &quantidade_ra); 7 | for(i = 0; i < quantidade_ra; i++) { 8 | scanf("%s", &ra_enviados); 9 | if(ra_enviados[0] == 'R' && ra_enviados[1] == 'A') { 10 | j = 2; 11 | while (ra_enviados[j] == '0') { 12 | j++; 13 | } 14 | k = 0; 15 | while (ra_enviados[j] != '\0') { 16 | senha_provisoria[k] = ra_enviados[j]; 17 | k++; 18 | j++; 19 | } 20 | if(j==20) { 21 | printf("%s\n", senha_provisoria); 22 | } 23 | } 24 | else { 25 | printf("INVALID DATA\n"); 26 | } 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /C/Iniciante/1985/1985.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int produtos, codigo, quantidade, i; 5 | float total = 0; 6 | 7 | scanf("%d", &produtos); 8 | 9 | for (i = 0; i < produtos; i++) { 10 | scanf("%d %d", &codigo, &quantidade); 11 | 12 | if (codigo == 1001) 13 | total += quantidade * 1.5; 14 | 15 | else if (codigo == 1002) 16 | total += quantidade * 2.5; 17 | 18 | else if (codigo == 1003) 19 | total += quantidade * 3.5; 20 | 21 | else if (codigo == 1004) 22 | total += quantidade * 4.5; 23 | 24 | else if (codigo == 1005) 25 | total += quantidade * 5.5; 26 | } 27 | 28 | printf("%.2f\n", total); 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /C/Iniciante/2221/2221.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T, B; 5 | int A[2], D[2], L[2], Golpe[2]; 6 | int i; 7 | 8 | scanf("%d",&T); 9 | 10 | for(i = 1; i <= T; i++) { 11 | scanf("%d",&B); 12 | scanf("%d %d %d",&A[0], &D[0], &L[0]); 13 | scanf("%d %d %d",&A[1], &D[1], &L[1]); 14 | 15 | Golpe[0] = (A[0] + D[0]) / 2; 16 | Golpe[1] = (A[1] + D[1]) / 2; 17 | 18 | if(L[0]%2 == 0) 19 | Golpe[0] = Golpe[0] + B; 20 | 21 | if(L[1]%2 == 0) 22 | Golpe[1] = Golpe[1] + B; 23 | 24 | if(Golpe[0] == Golpe[1]) 25 | printf("Empate\n"); 26 | 27 | else { 28 | 29 | if(Golpe[0] > Golpe[1]) 30 | printf("Dabriel\n"); 31 | else 32 | printf("Guarte\n"); 33 | 34 | } 35 | } 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /C/Strings/1238/1238.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | 6 | int i, j, tamanho1, tamanho2, maior, N; 7 | char string1[55], string2[55]; 8 | scanf("%d", &N); 9 | for (i = 0; i < N; i++) 10 | { 11 | scanf("%s %s", &string1, &string2); 12 | tamanho1 = strlen(string1); 13 | tamanho2 = strlen(string2); 14 | if (tamanho1 < tamanho2) 15 | maior = tamanho2; 16 | else 17 | maior = tamanho1; 18 | for (j = 0; j < maior; j++) 19 | { 20 | if (j < tamanho1) 21 | printf("%c", string1[j]); 22 | if (j < tamanho2) 23 | printf("%c", string2[j]); 24 | } 25 | printf("\n"); 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /C/Strings/2025/2025.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | 6 | int n, i, j; 7 | char frase[101]; 8 | 9 | scanf("%d", &n); 10 | 11 | for(i = 0; i < n; i++) { 12 | scanf(" %100[^\n]", frase); 13 | 14 | j = 0; 15 | while (j < strlen(frase) - 8) { 16 | if ((frase[j] == 'o') && (frase[j+1] == 'u') && (frase[j+2] == 'l') && (frase[j+3] == 'u') 17 | && (frase[j+4] == 'p') && (frase[j+5] == 'u') && (frase[j+6] == 'k') && (frase[j+7] == 'k')) { 18 | frase[j-1] = 'J'; 19 | frase[j+8] = 'i'; 20 | } 21 | j++; 22 | } 23 | 24 | printf("%s\n", frase); 25 | } 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /C/Strings/2651/2651.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int temZelda(char *nome); 5 | 6 | int main () 7 | { 8 | char nome[100001]; 9 | 10 | scanf("%s", nome); 11 | 12 | if (!temZelda(nome)) 13 | printf("Link Tranquilo\n"); 14 | else 15 | printf("Link Bolado\n"); 16 | 17 | return 0; 18 | } 19 | 20 | int temZelda(char *nome) 21 | { 22 | int i, j, contador = 0; 23 | char comparacao[6] = "zelda"; 24 | 25 | for (i = 0, j = 0; nome[i]; i++) 26 | { 27 | if (nome[i] == comparacao[j] || nome[i] == comparacao[j] + 32 || nome[i] == comparacao[j] - 32) 28 | { 29 | j++; 30 | contador++; 31 | 32 | if (contador == 5) 33 | return 1; 34 | } 35 | else 36 | { 37 | contador = 0; 38 | j = 0; 39 | } 40 | } 41 | return 0; 42 | } --------------------------------------------------------------------------------