fork download 
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <stdint.h>
  6.  
  7. void print_int128(__int128_t value);
  8. void print_uint128(__uint128_t value);
  9. __int128_t str_to_int128(const char *str);
  10. __int128_t abs128(__int128_t x);
  11. void zero(char* text, size_t size);
  12. void bitcounter(int b, char* text, __int128_t y);
  13. char* binary(__int128_t x);
  14.  
  15. int main(void)
  16. {
  17.     //FILE* filePtr;
  18.     //filePtr = freopen("Output.txt", "w", stdout);
  19.  
  20.     size_t t=0;
  21.     char input[500];
  22.     char text[10];
  23.     char number[50];
  24.     int b;
  25.     //long long int x;
  26.  
  27.     zero(input, sizeof(input));
  28.     zero(number, sizeof(number));
  29.     fgets(input, sizeof(input), stdin);
  30.     sscanf(input, "%zu", &t);
  31.  
  32.     for(size_t i=0; i<t; i++)
  33.     {
  34.         zero(input, sizeof(input));
  35.         zero(number, sizeof(number));
  36.         zero(text, sizeof(text));
  37.         b = 0;
  38.         //x = 0;
  39.  
  40.         fgets(input, sizeof(input), stdin);
  41.         sscanf(input, "%d %s %s", &b, text, number);
  42.  
  43.         size_t len = strlen(number);
  44.         if (number[len - 1] == '\n') 
  45.         {
  46.             number[len - 1] = '\0';
  47.         }
  48.  
  49.         __int128_t x = str_to_int128(number);
  50.  
  51.         bitcounter(b, text, x);
  52.     }
  53.  
  54.     //fclose(filePtr);
  55.     return 0;
  56. }
  57.  
  58. void zero(char* text, size_t size)
  59. {
  60.     for(size_t i=0; i<size; i++)
  61.     {
  62.         text[i] = '\0';
  63.     }
  64. }
  65.  
  66. void bitcounter(int b, char* text, __int128_t y)
  67. {
  68.     __int128_t x = y;
  69.     __int128_t full64signed = 9223372036854775808ULL;
  70.     __int128_t full64unsigned = 18446744073709551615ULL;
  71.     char value[129];
  72.     zero(value, sizeof(value));
  73.  
  74.     char* binaryPtr;
  75.     if(strcmp(text, "SIGNED") == 0 && x<0) {binaryPtr = binary(abs128(y)-1);}
  76.     else {binaryPtr = binary(abs128(y));}
  77.     //printf("binaryPtr: %s\n", binaryPtr);
  78.     strcpy(value, binaryPtr);
  79.     //printf("value: %s\n", value);
  80.     free(binaryPtr);
  81.  
  82.     char fin[129];
  83.     zero(fin, sizeof(fin));
  84.  
  85.     sprintf(fin, "%s", &value[128-b]);
  86.     //printf("fin: %s\n", fin);
  87.  
  88.     if(strcmp(text, "SIGNED") == 0)
  89.     {
  90.         if(x<0)
  91.         {
  92.             if(b == 2)
  93.             {
  94.                 if(x < -2) {printf("-2 1 Ups\n");}
  95.                 else if(x == -1) {printf("-2 1 10\n");}
  96.                 else if(x == -2) {printf("-2 1 11\n");}
  97.             }
  98.             else if(b == 3)
  99.             {
  100.                 if(x < -4) {printf("-4 3 Ups\n");}
  101.                 else if(x == -1) {printf("-4 3 1%s\n", &fin[1]);}
  102.                 else {printf("-4 3 1%s\n", &fin[1]);}
  103.             }
  104.             else if(b > 3 && b < 64)
  105.             {
  106.                 unsigned long long int minimum = (long double)powl(2,b-1);
  107.                 unsigned long long int maximum = (long double)powl(2,b-1)-1;
  108.                 __int128_t xu = abs128(x);
  109.                 if(xu > (long double)powl(2,b-1)) {printf("-%llu %llu Ups\n", minimum, maximum);}
  110.                 else {printf("-%llu %llu 1%s\n", minimum, maximum, &fin[1]);}
  111.             }
  112.             else
  113.             {
  114.                 unsigned long long int minimum = (long double)powl(2,b-1);
  115.                 unsigned long long int maximum = (long double)powl(2,b-1)-1;
  116.                 __int128_t xu = abs128(x);
  117.                 if(xu > (long double)powl(2,b-1) || xu > full64signed) {printf("-%llu %llu Ups\n", minimum, maximum);}
  118.                 else {printf("-%llu %llu 1%s\n", minimum, maximum, &fin[1]);}
  119.             }
  120.         }
  121.         else
  122.         {
  123.             if(b == 2)
  124.             {
  125.                 if(x>1) {printf("-2 1 Ups\n");}
  126.                 else if(x == 0) {printf("-2 1 00\n");}
  127.                 else if(x == 1) {printf("-2 1 01\n");}
  128.             }
  129.             else if(b == 3)
  130.             {
  131.                 if(x > 3) {printf("-4 3 Ups\n");}
  132.                 else {printf("-4 3 %s\n", fin);}
  133.             }
  134.             else
  135.             {
  136.                 unsigned long long int minimum = (long double)powl(2,b-1);
  137.                 unsigned long long int maximum = (long double)powl(2,b-1)-1;
  138.                 __uint128_t xu = abs128(x);
  139.                 __uint128_t maxValue = ((__uint128_t)1 << b) - 1;
  140.                 if(xu > (long double)(powl(2, b-1))-1 || xu > maxValue) {printf("-%llu %llu Ups\n", minimum, maximum);}
  141.                 else {printf("-%llu %llu %s\n", minimum, maximum, fin);}
  142.             }
  143.         }
  144.     }
  145.     else if(strcmp(text, "UNSIGNED") == 0)
  146.     {
  147.         if(b == 0)
  148.         {
  149.             printf("0 0 Ups\n");
  150.         }
  151.         else if(b == 1)
  152.         {
  153.             if(x>1) {printf("0 1 Ups\n");}
  154.             else if(x == 1) {printf("0 1 1\n");}
  155.             else if(x == 0) {printf("0 1 0\n");}
  156.         }
  157.         else if(b == 2)
  158.         {
  159.             if(x>3) {printf("0 3 Ups\n");}
  160.             else printf("0 3 %s\n", fin);
  161.         }
  162.         else
  163.         {
  164.             unsigned long long int maximum = (long double)powl(2,b)-1;
  165.             __uint128_t xu = abs128(x);
  166.             if(xu > (long double)powl(2,b) || xu > full64unsigned || x<0) {printf("0 %llu Ups\n", maximum);}
  167.             else {printf("0 %llu %s\n", maximum, fin);}
  168.         }
  169.     }
  170. }
  171.  
  172. char* binary(__int128_t x) 
  173. {
  174.     char* result = (char*)malloc(129 * sizeof(char)); // 128 bitów + 1 dla '\0'
  175.     if (!result) 
  176.     {
  177.         fprintf(stderr, "Memory allocation failed\n");
  178.         exit(EXIT_FAILURE);
  179.     }
  180.  
  181.     result[128] = '\0';
  182.  
  183.     for (int i = 127; i >= 0; i--) {
  184.         result[i] = (x & 1) ? '1' : '0';
  185.         x >>= 1;
  186.     }
  187.  
  188.     return result;
  189. }
  190.  
  191. void print_int128(__int128_t value) 
  192. {
  193.     if (value == 0) 
  194.     {
  195.         printf("0");
  196.         return;
  197.     }
  198.  
  199.     char buffer[40];
  200.     int i = 39;
  201.     buffer[i] = '\0';
  202.     i--;
  203.  
  204.     int negative = 0;
  205.     if (value < 0) 
  206.     {
  207.         negative = 1;
  208.         value = -value;
  209.     }
  210.  
  211.     while (value > 0) 
  212.     {
  213.         buffer[i] = '0' + (value % 10);
  214.         value /= 10;
  215.         i--;
  216.     }
  217.  
  218.     if (negative) 
  219.     {
  220.         buffer[i] = '-';
  221.         i--;
  222.     }
  223.  
  224.     printf("%s", &buffer[i + 1]);
  225. }
  226.  
  227. __int128_t str_to_int128(const char *str) 
  228. {
  229.     __int128_t result = 0;
  230.     int sign = 1;
  231.  
  232.     if (*str == '-') 
  233.     {
  234.         sign = -1;
  235.         str++;
  236.     }
  237.  
  238.     while (*str) 
  239.     {
  240.         result = result * 10 + (*str - '0');
  241.         str++;
  242.     }
  243.  
  244.     return sign * result;
  245. }
  246.  
  247. __int128_t abs128(__int128_t x) 
  248. {
  249.     return (x < 0) ? -x : x;
  250. }
  251.  
  252. void print_uint128(__uint128_t value) 
  253. {
  254.     if (value == 0) 
  255.     {
  256.         printf("0");
  257.         return;
  258.     }
  259.  
  260.     char buffer[40]; // 128-bitowa liczba całkowita zmieści się w maksymalnie 39 cyfrach dziesiętnych
  261.     int i = 39;
  262.     buffer[i] = '\0';
  263.     i--;
  264.  
  265.     while (value > 0) 
  266.     {
  267.         buffer[i] = '0' + (value % 10);
  268.         value /= 10;
  269.         i--;
  270.     }
  271.  
  272.     printf("%s", &buffer[i + 1]);
  273. }
  274.  
Success #stdin #stdout 0.01s 5280KB
comments (?)
stdin 
5
1 UNSIGNED -1
1 UNSIGNED 0
1 UNSIGNED 1
1 UNSIGNED 2
2 UNSIGNED -1
stdout 
0 1 0
0 1 1
0 1 Ups
0 3 01
https://ideone.com/meJElB
language:
C (gcc 8.3)
created:
1 year ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!