int c, sp;
sp = 0;
while ((c = getchar()) != EOF)
{
   if (c == ' ')
   {
      putchar(c);
      while ((c = getchar()) == ' ')
         ;
   }
   putchar (c);
}

aij (I# i) (I# j) = D# (
    case i +# j of
        n -> 1.0## /## int2Double#
        	(((n *# (n+#1#)) `uncheckedIShiftRA#` 1#) +# (i +# 1#)))

while(true) // 1й
{
    break(2); // выходим из 2го цикла
}

#include <stdlib.h>
#include <stdio.h>
#include <setjmp.h>

int main() 
{
        jmp_buf buf;
        if (!setjmp(buf))
                for (int i = 0; i < 10; i++)
                        for (int j = 0; j < 10; j++) {
                                printf("(i,j) = (%d,%d)\n", i, j);
                                if (10 * i + j == 42)
                                        longjmp(buf, 1);
                        }
        else
                puts("voila!");

        /* rest of the program */
        return 0;
}

$ man структурное программирование
man: no entry for структурное in the manual.
man: no entry for программирование in the manual.

signature YOBA =
sig
    type yoba
    val newI: yoba
    val newS: yoba
    val yobafun: yoba -> int
end

structure Yoba :> YOBA =
struct

datatype yoba =
         Yoba1 of int
       | Yoba2 of string

fun yobafun (Yoba1 i) = i
  | yobafun (Yoba2 s) = size s

val newI = Yoba1 42

val newS = Yoba2 "fourtytwo"
end

- val x = Yoba.newS;
val x = - : Yoba.yoba
- val y = Yoba.newI;
val y = - : Yoba.yoba
- Yoba.yobafun x;
val it = 9 : int
- Yoba.yobafun y;
val it = 42 : int

enum ptype {pint,pstr,pch};

typedef struct {
   ptype tag;
   union {
      char c;
      int i;
      char * s;
   } v;
} pval;

pval somefun(pval a, pval b) {
  ...
}

if (arrf[countf] == 1) return 1;
return 0;

struct E_str {
  int first;
  char second;
};
...
struct E_str* e;
/* Можно так */
int one = (*e).first;
/* или со стрелкой*/
one = e->first;

switch (e->keycode)
{
    case UP:
        Ynw-- = (y[0]); 
        Xnw = (x[0]);

 switch (e->keycode)
{
    case UP:
        Ynw = (y[0]-1); 
        Xnw = (x[0]);

 switch (e->keycode)
{
    case UP:
        Ynw = (y[0]); 
        Ynw--;
        Xnw = (x[0]);

inline void read_KeyPress (XEvent *eventp, unsigned int *x,
                   unsigned int  *y, unsigned int *mv,
                   char *plusminus, Display *d, Window w,
                   unsigned int s, unsigned int *LENGTH,
                   unsigned int *xrand, unsigned int *yrand)

--- p1.c	2010-08-29 15:20:29.000000000 +0400
+++ p2.c	2010-08-29 15:20:12.000000000 +0400
@@ -1,10 +1,10 @@
 #include <X11/Xlib.h>
  #include <stdio.h>
  #include <stdlib.h>
- #define LEFT_BORDER 400
- #define DOWN_BORDER 300
- #define x0 200
- #define y0 100
+ #define LEFT_BORDER (200*3)
+ #define DOWN_BORDER (200*3)
+ #define x0 (100*3)
+ #define y0 (100*3)
 
  #define UP 111
  #define DOWN 116
@@ -32,7 +32,7 @@
          unsigned int *x, unsigned int *y)
 {
     XSetForeground(d, DefaultGC(d, s), 0x000000);
-    XDrawPoint(d, w, DefaultGC(d, s), x[0], y[0]); //закрашиваем черным то место, где была голова
+    XDrawRectangle(d, w, DefaultGC(d, s), x[0], y[0], 2, 2); //закрашиваем черным то место, где была голова
 }
 
 
@@ -41,7 +41,7 @@
          unsigned int *x, unsigned int *y, unsigned int mv)
 {
     XSetForeground(d, DefaultGC(d, s), 0xFFFFFF);
-    XDrawPoint(d, w, DefaultGC(d, s), x[mv], y[mv]); //закрашиваем белым то место, где был зад
+    XDrawRectangle(d, w, DefaultGC(d, s), x[mv], y[mv], 2, 2); //закрашиваем белым то место, где был зад
 }
 
 
@@ -58,14 +58,14 @@
          unsigned int *x, unsigned int *y)
 {
     XSetForeground(d, DefaultGC(d, s), 0xFF0000);
-    XDrawPoint(d, w, DefaultGC(d, s), x[0], y[0]); //рисуем красную головку
+    XDrawRectangle(d, w, DefaultGC(d, s), x[0], y[0], 2, 2); //рисуем красную головку
 }
 
 inline void draweatpoint (Display *d, Window w, unsigned int s,
          unsigned int *xrand, unsigned int *yrand)
 {
     XSetForeground(d, DefaultGC(d, s), 0x00FF00);
-    XDrawPoint(d, w, DefaultGC(d, s), *xrand, *yrand); //рисуем точку для пожирания
+    XDrawRectangle(d, w, DefaultGC(d, s), *xrand, *yrand, 2, 2); //рисуем точку для пожирания
 }
 
 inline void read_KeyPress (XEvent *eventp, unsigned int *x,
@@ -79,23 +79,23 @@
     switch (e->keycode)
     {
         case UP:
-            Ynw = y[0]-1;
+            Ynw = y[0]-3;
             Xnw = x[0];
             break;
         case DOWN:
-            Ynw = (y[0]+1);
+            Ynw = (y[0]+3);
             Xnw = x[0];
             break;
         case LEFT:
             Ynw = y[0];
-            Xnw = x[0]-1;
+            Xnw = x[0]-3;
             break;
         case RIGHT:
             Ynw = y[0];
-            Xnw = x[0]+1;
+            Xnw = x[0]+3;
     }
-    if (((Xnw!=x[0]) ^ (Ynw!=y[0])) && ((Xnw) != (LEFT_BORDER-1)) \
-        && ((Ynw) != (DOWN_BORDER-1)) && (selfeat (x, y, Xnw, Ynw, *LENGTH)) \
+    if (((Xnw!=x[0]) ^ (Ynw!=y[0])) && ((Xnw) != (LEFT_BORDER-3)) \
+        && ((Ynw) != (DOWN_BORDER-3)) && (selfeat (x, y, Xnw, Ynw, *LENGTH)) \
         && ((Xnw) != 0) && ((Ynw) != 0) )
     {
         blacktohead (d, w, s, x, y);
@@ -126,9 +126,9 @@
  
 int main(void) 
 {
-    unsigned int xrand=5;
-    unsigned int yrand=5;
-    unsigned int LENGTH = 10;
+    unsigned int xrand=9;
+    unsigned int yrand=9;
+    unsigned int LENGTH = 3;
     unsigned int x[500], y[500];
     Display *d;
     Window w;
@@ -158,7 +158,7 @@
     count = 2;
     do
     {
-        x[count]=1+x0-count;
+        x[count]=3+x0-(count*3);
         y[count]=y0;
         count++;
     }
@@ -173,7 +173,7 @@
     mv=1;
     x[0]=x0;
     y[0]=y0;
-    x[1]=x0-LENGTH+1;
+    x[1]=x0-(LENGTH*3)+3;
     y[1]=y0;
     
                            /* event loop */
@@ -184,13 +184,13 @@
         if (e.type == Expose)
         {
             XSetForeground(d, DefaultGC(d, s), 0xFF0000);
-            XDrawPoint(d, w, DefaultGC(d, s), x[0], y[0]);
+            XDrawRectangle(d, w, DefaultGC(d, s), x[0], y[0], 2, 2);
             count=1;
             XSetForeground(d, DefaultGC(d, s), 0x000000);
             //рисуем змею
             do
             {
-                XDrawPoint(d, w, DefaultGC(d, s), x[count], y[count]);
+                XDrawRectangle(d, w, DefaultGC(d, s), x[count], y[count], 2, 2);
                 count++;
             }
             while (count != (LENGTH));

#define randomize() srand((unsigned)time(NULL))
#define random(a, b) rand()*(b-a)+a

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define randomize() srand((unsigned)time(NULL))
#define random(a, b) rand()*(b-a)+a
int main(void) 
{
    unsigned int i;
    for (i = 1; i != 10; i++)
    {
        printf (" %d", random(10, 20));
        randomize();
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define randomize() srand((unsigned)time(NULL))
#define random(a, b) rand()*(b-a)+a
int main(void) 
{
    unsigned int i;
    for (i = 1; i != 200; i++)
    {
        printf (" %d", random(10, 20));
        randomize();
    }
    return 0;
}

#define random(a, b) rand()*(b-a)/RAND_MAX+a

#define random(a, b) ((rand() % (b - a + 1)) + a)

yoba = unlines . map mapLine . lines

    where mapLine []                   = []
          mapLine x | all ((==) ' ') x = " "
                    | otherwise        = x

Напишите программу для вывода входного потока по одному слову в строке.

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    int c;
    while ((c = getchar()) != EOF)
    {
        if (c == ' ' || c == '\n' || c == '\t')
        {
            putchar ('\n');
            while (c == ' ' || c == '\n' || c == '\t')
                c = getchar();
        }
        putchar (c);
    }
    return 0;
}

#include <stdio.h>

int main(void)
{
    int c;
    do c = getchar(); while (c == '1');
    printf ("char: %d", c);
    return 0;
}

getLine >>= putStr . unlines . words

getLine >>= mapM putStrLn . words

Ждем нажатия клавиши 0.5 сек.
если что-то нажато то
в зависимости от того, что нажато,
    мы или поворачиваем фигуру по или против часовой стрелки
    или немедленно опускаем фигуру вниз,
    или ничего не делаем и продолжам ждать.
Если ничего не нажато в течении 0.5 сек., то просто опускаем фигуру на 1 пункт

char *a = malloc(10);

a[0]=2; a[1]=5; a[2]=3; a[3]=8;

putarr(a, 2, 5, 3, 8);

a[3]=77; a[6]=55; a[7]=11; a[9]=66;

putarrplace(a,
               3, 77,
               6, 55,
               7, 11,
               9, 66  );

#define PUTARR(a,type,...) { type src[]={__VA_ARGS__};memcpy((a),&src,sizeof(src)); }

PUTARR(a,int,
            2,5,3,8);

#include <stdio.h>
#include <stdlib.h>

int main() {
        int a[] = {1, 28, 55, 6, 27, 24, 2, 82, 14, 83};
        for (int i = 0; i != 10; i++)
                printf("%i ", a[i]);
        printf("\n");
        getchar();
        return 0;
}

int a[] = {1, 28, 55, 6, 27, 24, 2, 82, 14, 83};
for (int i = 0; i != 10; i++)
        printf("%i ", a[i]);
a* = {6, 28, 222, 33}; //захотелось мне поменять первые четыре элемента массива
for (int i = 0; i != 10; i++)
        printf("%i ", a[i]);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
        int a[] = {1, 28, 55, 6, 27, 24, 2, 82, 14, 83};
        for (int i = 0; i != 10; i++) printf("%i ", a[i]);
        printf("\n");
        int _[] = {6, 28, 222, 33};
        memcpy(a, _, 4 * sizeof(int));
        for (int i = 0; i != 10; i++) printf("%i ", a[i]);
        getchar();
        return 0;
}

    int _[] = {6, 28, 222, 33};
    memcpy(a, _, 4 * sizeof(int));

memcpy(a, (int[]){7, 29, 224, 36}, 4 * sizeof(int));

type a[n];
type *a = alloca( n*sizeof(type) );

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void my_char_plus(const void *a, const void *b, void *c)
{
    char tmp =  (*(char*)a + *(char*)b);
    memcpy(c,(void*)(&tmp),sizeof(char));
}

void operation(const void *funct(const void*,const void*,void*),
                      const void *a, const void *b, void *c )
{
    funct(a,b,c);
}

int main(void)
{
    char a, b, c;
    a = 5; b = 7;
    
    void *plus = &my_char_plus;
    operation(plus, (const void*)&a, (const void*)&b, (void*)&c);
    printf("%i\n", c);
    
    return 0;
}

 void *plus = &my_char_plus;

void operation(const void *funct(const void*,const void*,void*),

     +-+-+-+-+-+-+  +-+-+-+-+-+-+  +-+-+-+-+-+-+
...-->*|a|b|c|d|*<-->*|e|f|g|h|*<-->*|i|j|k|l|*<--...
     +-+-+-+-+-+-+  +-+-+-+-+-+-+  +-+-+-+-+-+-+

#include <iostream>

void main()
{
    std::cout << "Hello, world!";
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void)
{

int8_t n[] = {'9', '8', '7', '6', '5', '4', '3', '2'};
uint64_t* a = (uint64_t *)n;
*a =((*a & 0x0F000F000F000F00)>>8) +\
    ((*a & 0x000F000F000F000F)*10);

*a = 1000000 * ((*a >> 0 ) & 0xFF) +\
       10000 * ((*a >> 16) & 0xFF) +\
         100 * ((*a >> 32) & 0xFF) +\
               ((*a >> 48) & 0xFF);
//little-endian only. Можно переделать под big-endian
printf("%"PRId64, *a);

return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>
const char n[] = {'T', 'E', 'S', 'T', '\n'};
void _start(void)
{
  write(STDOUT_FILENO, n, sizeof(n)); 
  _exit(0);
}

Disassembly of section .plt:

0000000000400378 <_exit@plt-0x10>:
  400378:	ff 35 72 0c 20 00    	pushq  0x200c72(%rip)        # 600ff0 <_GLOBAL_OFFSET_TABLE_+0x8>
  40037e:	ff 25 74 0c 20 00    	jmpq   *0x200c74(%rip)        # 600ff8 <_GLOBAL_OFFSET_TABLE_+0x10>
  400384:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000400388 <_exit@plt>:
  400388:	ff 25 72 0c 20 00    	jmpq   *0x200c72(%rip)        # 601000 <_GLOBAL_OFFSET_TABLE_+0x18>
  40038e:	68 00 00 00 00       	pushq  $0x0
  400393:	e9 e0 ff ff ff       	jmpq   400378 <_exit@plt-0x10>

0000000000400398 <write@plt>:
  400398:	ff 25 6a 0c 20 00    	jmpq   *0x200c6a(%rip)        # 601008 <_GLOBAL_OFFSET_TABLE_+0x20>
  40039e:	68 01 00 00 00       	pushq  $0x1
  4003a3:	e9 d0 ff ff ff       	jmpq   400378 <_exit@plt-0x10>

Disassembly of section .text:

00000000004003b0 <_start>:
  4003b0:	bf 01 00 00 00       	mov    $0x1,%edi
  4003b5:	48 83 ec 08          	sub    $0x8,%rsp
  4003b9:	ba 05 00 00 00       	mov    $0x5,%edx
  4003be:	be cf 03 40 00       	mov    $0x4003cf,%esi
  4003c3:	e8 d0 ff ff ff       	callq  400398 <write@plt>
  4003c8:	31 ff                	xor    %edi,%edi
  4003ca:	e8 b9 ff ff ff       	callq  400388 <_exit@plt>

  asm(
  "mov $0, %rdi\n"
  "mov $60, %rax\n"
  "syscall\n");

Disassembly of section .plt:

0000000000400340 <write@plt-0x10>:
  400340:	ff 35 aa 0c 20 00    	pushq  0x200caa(%rip)        # 600ff0 <_GLOBAL_OFFSET_TABLE_+0x8>
  400346:	ff 25 ac 0c 20 00    	jmpq   *0x200cac(%rip)        # 600ff8 <_GLOBAL_OFFSET_TABLE_+0x10>
  40034c:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000400350 <write@plt>:
  400350:	ff 25 aa 0c 20 00    	jmpq   *0x200caa(%rip)        # 601000 <_GLOBAL_OFFSET_TABLE_+0x18>
  400356:	68 00 00 00 00       	pushq  $0x0
  40035b:	e9 e0 ff ff ff       	jmpq   400340 <write@plt-0x10>

Disassembly of section .text:

0000000000400360 <_start>:
  400360:	48 83 ec 08          	sub    $0x8,%rsp
  400364:	ba 05 00 00 00       	mov    $0x5,%edx
  400369:	be 8d 03 40 00       	mov    $0x40038d,%esi
  40036e:	bf 01 00 00 00       	mov    $0x1,%edi
  400373:	e8 d8 ff ff ff       	callq  400350 <write@plt>
  400378:	48 c7 c7 00 00 00 00 	mov    $0x0,%rdi
  40037f:	48 c7 c0 3c 00 00 00 	mov    $0x3c,%rax
  400386:	0f 05                	syscall 
  400388:	48 83 c4 08          	add    $0x8,%rsp
  40038c:	c3                   	retq

  asm volatile (
  "mov $0, %rdi\n"
  "mov $60, %rax\n"
  "syscall\n");
  printf("test");

  _exit(0);
  printf("test");