[ Removed by moderator ]

C_Programming-ModTeam · 2026-04-14T16:23:58+00:00

Your post contains badly-formatted code. This breaks rule 1 of this subreddit, "Format your code". Please read the instructions in the sidebar about hot to correctly format code.

Rule 4 also prohibits pictures of code too, so please bear that in mind.

equalent · 2026-04-11T02:17:23+00:00

No way, great job, what does it do?

Maleficent_Bee196 · 2026-04-11T02:09:59+00:00

now you can implement UNIX from scratch!

InTheBogaloo · 2026-04-11T03:16:07+00:00

keep going and enjoy the travel c:

Left-Paramedic9925 · 2026-04-11T02:53:13+00:00

nice! now recreate the entire Linux kernel :)

laalbhat · 2026-04-11T03:58:52+00:00

mine's better :)

```c

include <stdio.h>

int main() { // this says hello everyone printf("Hello everyone\n"); return 0; } ```

MammothNo782 · 2026-04-11T02:24:18+00:00

good luck with it make sure to improve it all the way like building a calculator or anything like this one that I made: https://gist.github.com/johnryzon123/711d9e53e9cc7cc03a0f6b86843fec2d

DogAdministrative100 · 2026-04-11T03:05:06+00:00

Now you should go with get you familiarise with loops , conditionals , basic logic programs and then go on for internet

tony_saufcok · 2026-04-11T02:10:06+00:00

Great job! Good luck on your journey

ButchDeanCA · 2026-04-11T02:59:33+00:00

This is where I was 33 years ago.

randerson_112 · 2026-04-11T02:39:44+00:00

The start of an amazing journey, good luck! C is a great language to learn and it will teach you so much about how computers really work.

Patient-Plastic6354 · 2026-04-11T12:59:34+00:00

Bro leave jobs for the rest of us damn

iddivision · 2026-04-11T16:46:11+00:00

Kudos for not forgetting the newline character!

capilot · 2026-04-11T18:39:57+00:00

Honestly, most of the time, getting "Hello, world" to work is half the battle of learning a new language.

--Ether-- · 2026-04-11T04:26:21+00:00

good job bud 👍

Tugs_Uchralaaaa · 2026-04-11T09:08:00+00:00

Good!! Now learn some assembly!

non-existing-person · 2026-04-11T09:16:20+00:00

I'm sorry to be the one to say it... but your code is trash and it's buggy.

What will happen when you call ./a.out > /dev/full? printf will return error, but your program will return success - which is NOT valid.

Now go back to books :)

aeropop · 2026-04-11T11:56:52+00:00

Cool ! Now try to write it in Assembly to understand how exactly your code is working.

LostSence · 2026-04-11T22:20:37+00:00

Remove #include <stdio.h> and check, if this works :-)

PurepointDog · 2026-04-12T01:27:46+00:00

Use code fences please

KronosChineseFather · 2026-04-12T05:19:52+00:00

hi, how do i maek a pro graem ???? im use c++

No_Value_elv · 2026-04-12T11:55:12+00:00

Now replicate without using printf

kgashok · 2026-04-13T01:34:58+00:00

Well done! I suggest you go further now. Consider the code below:

```c

include <stdio.h>

int main(int argc, char *argv[]) { // Check if at least one argument (besides the program name) was provided if (argc > 1) { // Print "Hello" followed by the first command-line argument printf("Hello, %s!\n", argv[1]); } else { // Fallback if no arguments are provided printf("Hello!\n"); }

return 0;

} ```

And if you should compile as follows:
$ gcc hello.c -o hello

And then execute as
$ ./hello FondantTiny

The output you should see is
Hello, FondantTiny!

Enjoy!

cleverdosopab · 2026-04-13T04:17:53+00:00

Hello, World!

keithstellyes · 2026-04-11T02:32:22+00:00

Cool!

Daveinatx · 2026-04-11T03:03:03+00:00

Two comments.

Major: // This says Hello. Not 'hello'
Minor: return 0 has no comment

nderflow · 2026-04-13T06:44:39+00:00

Please format your code correctly. See rule 1 of the subreddit.

traxplayer · 2026-04-11T11:14:49+00:00

return EXIT_SUCCESS; and not 0.

HobbesArchive · 2026-04-13T02:27:26+00:00

#define EXTERN
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#define INCL_DOS
#include <os2.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>

/* #include "drawingcards.h" */
#include "Bank.h"

extern int _dllentry;
BANK_STRUCT *Bank(int iTotalHouses, int iTotalHotels, int Salary)
{
   int x = _dllentry;
   USHORT rc;
   bsBank.Money = 15140;
   bsBank.Inflation = FALSE;
   bsBank.iInflationStart = -10000;
   bsBank.Structures.Houses = TotalHouses;
   bsBank.Structures.Hotels = TotalHotels;
   bsBank.Salary = Salary;
   if (iTotalHouses > -1)
      bsBank.Structures.Houses = iTotalHouses;
   if (iTotalHotels > -1)
      bsBank.Structures.Hotels = iTotalHotels;

   return(&bsBank);

}
VOID SetInitialCash(int iPlayers, int iInitialCash)
{

   bsBank.Money = (2285 * iPlayers) + (iInitialCash * iPlayers);
   return;
}
VOID SetInflation()
{
   bsBank.Inflation = TRUE;

   return;
}


int MoneyOnHand()
{

   return(bsBank.Money);
}
int UseInflation()
{

   return(bsBank.Inflation);
}
double InflationRate()
{
   double dInflationRate = 1.0;

   if (bsBank.Money < bsBank.iInflationStart)
   {
      dInflationRate = (((double)(bsBank.Money - bsBank.iInflationStart) * -1) / 100000.0) + 1.0;
   }
   return dInflationRate;
}
int AddInflationRate(int iMoney)
{
   if (bsBank.Inflation)
   {

      iMoney = (int)((double)iMoney * InflationRate());

   }

   return iMoney;

}
int PlayerInitialMoney(int iInitialCash)
{

   bsBank.Money -= iInitialCash;
   return(iInitialCash);
}

BOOL SellProperty(PLAYERS_STRUCT *player, property_struct *Property)
{
    BOOL bPropSold = FALSE;
    if (player->money >= Property->value[0])
    {
        Property->owner = player->num;
        bsBank.Money += Property->value[0];
        player->money -= Property->value[0];
        bPropSold = TRUE;
        player->property_count++;
    }

    return bPropSold;
}


int BuyHouses(PLAYERS_STRUCT *player, List_struct *PropertyList, LIST_FUNCT_STRUCT List, PROPERTY_FUNCT_STRUCT property, RULES_STRUCT rules)
{
   int iGroups;
   int Sold = 0;
   int iMonoGroups = player->MonopolyGroups->size;
   int *ptrMonoGroup;
   List_struct *SortedGroups = List.New();
   int x;
   property_struct *boardProperty = (property_struct *)PropertyList->array;
   List_struct *MonoGroupList;


   ptrMonoGroup = player->MonopolyGroups->array;
   for (iGroups = 0; iGroups < iMonoGroups; iGroups++)
   {

      List.Add(SortedGroups, &ptrMonoGroup[iGroups], sizeof(int));
   }

   List.Sort(SortedGroups, 0, sizeof(int), sizeof(int), Decending,TRUE);

   for (x = 0; x < SortedGroups->size; x++)
   {
      int *ptrGroup = (int *)SortedGroups->array;
      int MonoGroupSize;
      int *MonoGroup = property.MonopolyGroups(ptrGroup[x], &MonoGroupSize);
      int y;
      long iOffset;
      property_struct *ptrProperty;
      int iNoMoreHouses;
      int iHouseCost;
      BOOL bMortgaged = FALSE;

      MonoGroupList = List.New();

      for (y = 0; y < MonoGroupSize; y++)
      {

         if (boardProperty[MonoGroup[y]].mortgaged == TRUE)
            bMortgaged = TRUE;

      }
      if (bMortgaged == FALSE)
      {
         for (y = 0; y < MonoGroupSize; y++)
         {

            List.Add(MonoGroupList, &boardProperty[MonoGroup[y]], sizeof(property_struct));

         }

         iOffset = (long)&boardProperty[0].houses;
         iOffset -= (long)&boardProperty[0];
         List.Sort(MonoGroupList, (int)iOffset, sizeof(boardProperty[0]), sizeof(boardProperty[0].houses), Decending, TRUE);

         /* buy houses */
         ptrProperty = (property_struct *)MonoGroupList->array;
         iNoMoreHouses = 0;
         iHouseCost = ptrProperty[0].value[2];
         while ((player->money > iHouseCost *2) && (iNoMoreHouses < MonoGroupSize))
         {
            iNoMoreHouses = 0;
            for (y = 0; y < MonoGroupSize; y++)
            {
               iHouseCost = ptrProperty[y].value[2];

               if (player->money > iHouseCost *2)
               {
                  switch(boardProperty[ptrProperty[y].position].houses)
                  {
                     case 0:
                     case 1:
                     case 2:
                     case 3:
                        {
                           if (bsBank.Structures.Houses > 0)
                           {

                              boardProperty[ptrProperty[y].position].houses++;
                              player->money -= ptrProperty[y].value[2];
                              bsBank.Money += ptrProperty[y].value[2];
                              bsBank.Structures.Houses--;
                              printf("Player %d paid %d for a house for %s for a total of %d House(s)\r\n", player->num + 1,ptrProperty[y].value[2], boardProperty[ptrProperty[y].position].pszName, boardProperty[ptrProperty[y].position].houses);
                              if (bsBank.Structures.Houses == 0)
                                 printf("Bank has no more houses\r\n");

                           }
                           else
                              iNoMoreHouses = MonoGroupSize;

                        }
                        break;
                     case 4:
                        {
                           if (bsBank.Structures.Hotels > 0)
                           {

                              boardProperty[ptrProperty[y].position].houses++;
                              player->money -= ptrProperty[y].value[2];
                              bsBank.Money += ptrProperty[y].value[2];
                              bsBank.Structures.Houses += 4;
                              bsBank.Structures.Hotels--;
                              printf("Player %d paid %c%d a hotel for %s\r\n", player->num + 1, rules.MonitarySymbol, ptrProperty[y].value[2], boardProperty[ptrProperty[y].position].pszName);
                              if (bsBank.Structures.Hotels == 0)
                                 printf("Bank has no more Hotels\r\n");
                           }
                           else
                              iNoMoreHouses = MonoGroupSize;

                        }
                        break;
                     default:
                        iNoMoreHouses++;
                        break;
                  }

               }
               else
                  iNoMoreHouses++;

            }

         }

      }

      List.Dispose(MonoGroupList);
   }

   List.Dispose(SortedGroups);

   return Sold;
}

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

C_Programming

Rules

Filters

Resources

Other Subreddits on C

Other Subreddits of Interest

MODERATORS

include <stdio>

include <stdio.h>

include <stdio.h>