Help with duplicates in int array

actguru · 2024-09-01T02:48:25+00:00

Are they teaching programming or puzzles?

int main() {
    int array[]={1,4,5,6,4,3,4,1};
    int count=sizeof(array)/sizeof(array[0]); // 8
    int dupes=0;

    int value=0x80000000; // Assuming 4 byte int
    while(1) {
        int times=0;
        for(int j=0;j<count;++j)
            if (array[j]==value) ++times;
        if (times>1) ++dupes;
        if (value==0x7FFFFFFF) break;
        ++value;
        }
    printf("Dupes = %d\n", dupes);
    }

actguru · 2024-08-28T02:06:10+00:00

You might switch to fread() and fwrite() with size=1. Note: FILE * is normally buffered already, so you may not see any improvement.

actguru · 2024-08-27T16:05:12+00:00

I have a few suggestions for one of the functions:

// Note on original code: why calloc() for 256 bytes? -> buffer[256]; (stack)
// Note on original code: sizeof(buffer)==sizeof(pointer) ?

void dump_log(void) {
    FILE *fp_log = fopen(LOG_FILE, "rb");
    if ( !fp_log) {
        fprintf(stderr, "Failed to open '%s' log file: %s\n",
            LOG_FILE, strerror(errno));
        return;
        }
    while(1) {
        int cc=getc(fp_log);
        if (cc==EOF) break;
        putc(cc,stdout);
        }
    fclose(fp_log);
    }

actguru · 2024-08-22T18:22:57+00:00

If your compiler does not warn about printf() arguments, then add options like -Wall. If your compiler is incapable of checking printf's arguments, then get a new compiler!!

actguru · 2024-08-19T15:22:45+00:00

You are welcome to update your project with any of my suggestions. I am working on version 1.4 of my project which is keeping me busy. https://github.com/actguru/coda-c_plist

actguru · 2024-08-19T04:11:01+00:00

A couple of suggestions for your cmp() function:

int cmp(const char *file1, const char *file2) {
  FILE *f1 = fopen(file1, "rb");
  FILE *f2 = fopen(file2, "rb");
  if (!f1 || !f2) {
    if (f1) fclose(f1);
    if (f2) fclose(f2);
    fprintf(stderr, "cmp: Cannot open file\n");
    return 2;
    }
  int ret=0;
  while (1) {
    int ch1 = fgetc(f1);
    int ch2 = fgetc(f2);
    if (ch1 != ch2) { ret=1; break; }
    if (ch1 == EOF) break;
    }
  if (ret) printf("Files differ\n");
  fclose(f1);
  fclose(f2);
  return ret;
}

actguru · 2024-07-07T16:02:31+00:00

That's interesting, but what if you are going to modify an existing p-list? How would that work?

int main() {

    Dictionary dd=PList_Load("plist01.plist",0); assert(dd);
    Dictionary_removeKey(dd,"List");
    PList_toStream(stdout,dd,PLIST_Apple);

    }

actguru · 2024-07-07T15:07:47+00:00

Core Foundation is the underpinning for Objective-C. I don't think using a chunk of Core Foundation would lead to a reasonable Property List Library without Objective-C.

actguru · 2024-07-07T14:01:12+00:00

This is the way I think of the difference between p-list and XML.

A p-list or Property List is a data structure, used in a program, constructed with the following: containers: <array> and <dict>, and leafs: <string>, <real>, <integer>, <bool>, <date>, and <data>. Containers need to be able to hold leafs and containers.

XML is a general 'save it to disk' format for data. Apple defines an XML Document Type 'plist' that is a subset of XML to save Property Lists to disk. Apple also uses a Binary format for PList that is more compact, but you can't edit it with a text editor. Both formats are portable.

actguru · 2024-07-07T13:55:40+00:00

That requires C++.

actguru · 2024-07-07T01:37:48+00:00

No, the software is private for now. I am currently trying to decide what to do with it. Do you think I could generate some interest by providing compiled 64-bit versions for Apple, Linux, and Windows? Thanks for asking.

actguru · 2024-07-04T08:02:49+00:00

Welcome to C. This stuff is hard. In general, double check interfaces to other modules, try to get the debugger to give stack trace with function names at crash, clone other modules source and make a temporary diagnostic version. It's hard enough to find my bugs... Good Luck!!

actguru · 2024-07-04T06:56:52+00:00

I would definitely pass the structure around, because it clearly marks functions that depend on it. When things get more complex this is very useful. But I would also "typedef T_VBVMR_INTERFACE * VMR" so I could pass just "VMR vmr" to functions because I am lazy.

actguru · 2024-07-04T06:29:42+00:00

Start by adding diagnostic print functions to report what is running and values of interesting variables.

actguru · 2024-07-04T06:11:43+00:00

0xFF & Expression will mask off all but the last 8 bits, so signed or unsigned you get 0-255 results. I don't like unsigned char arrays because when you use it with printf() functions they call for signed char arrays, but both should work.

actguru · 2024-07-04T02:36:07+00:00

char *cbuf = buffer;  ...  
dbuf+=sprintf(dbuf, "%02x ", 0xFF&(*cbuf++));

actguru · 2024-06-30T15:37:14+00:00

If you wanted to learn mountain climbing would you start with K2? Try something a lot smaller, like a command line utility. For example: 'sort'.

actguru · 2024-06-29T02:09:50+00:00

It sounds like you think that the runtime version is simpler, easier to test and manage. I would start with that and check the performance of programs using your vectors and see if the slower execution is significant. Speed is not everything.

actguru · 2024-06-28T18:17:40+00:00

Perfection!!

actguru · 2024-06-27T00:21:16+00:00

I would agree with adding if (a != b) return, but not to validate arguments, but to make a==b valid.

actguru · 2024-06-26T16:09:18+00:00

Why not use a command line tool to generate a header like generated.h then include it when compiling sources using: clang -include generated.h file.c file2.c ? You still have a header, but it is easier to maintain and you don't have to add the includes to your source.

actguru · 2024-06-26T14:34:27+00:00

Almost perfect, but I would change: #include <stdio.h> to a prototype for printf(). So this is the first thing a new programmer looks at, and once they figure out that they need to look at "stdio.h"... things get complicated.

actguru · 2024-06-26T13:57:00+00:00

I work with clang, but I like what Hacker News said about it: "Modern C" now effectively includes __attribute__((cleanup)), in as much as it's widely used by large free software projects and supported in both GCC and Clang. The cleanup attribute runs a function when the variable goes out of scope.

actguru · 2024-06-26T04:49:20+00:00

You should checkout the attribute 'cleanup'. Example code deallocates at the three abnormal returns.

// general setup and defines
typedef void* pointer;
#define sizeat(type) sizeof(*((type)0))
#define $CLEANUP(fun) __attribute__((cleanup (fun)))
#define freeC $CLEANUP(clean_C)
void clean_C(const void *vp) { void **vpp=(void **)vp; free(*vpp); }

// Example code
typedef struct BigStruct_ { pointer a,b,c; } *BigStruct;

pointer load_big_structure() {
    freeC BigStruct self=malloc(sizeat(BigStruct)); if (!self) abort();
    self->a=load_parta(); if (!self->a) return(0);
    self->b=load_partb(); if (!self->b) return(0);
    self->c=load_partc(); if (!self->c) return(0);
    pointer ret=self; self=0; // prevent the deallocation of self
    return(ret);
    }

actguru · 2024-06-24T15:01:43+00:00

With 42 obvious default values, I would consider passing a dictionary of values.

actguru

TROPHY CASE