האם אתם יודעים מה הקוד הזה עושה?

#include <stdio.h>

#define x char
#define z else
#define w gets
#define r if
#define u int
#define s main
#define v putchar
#define y while
#define t " A?B?K?L?CIF?MSP?E?H?O?R?DJG?NTQ?????U?V?????X???????Z????W??Y??"
void s (   )  {   x* c  ,  b[ 5  * 72   ]; u  a, e  ,  d   [  9
*9 *9 ]  ;    y  (w  ( b) ){            r  ( 0   [ b] -7 *
5        )    {  c  =     b    ;       y  (  (*    c  -  6
* 7 )* *  c )c =  c+ 1  ;   r ((   -0 )  [ c  ] &&  w (  b   +
  8 *  5*    3        ) && w          (b   +8      *5  * 6) )
  { a       =  0; y     (                  a       [     b  ]
 ) {    a [  d  ] = ! !    ( a[ b]   -   4 *8 )    ;  a  =   a +
1;  }   y (a   <  8 *  5      *  3   )  d      [   (   a ++ )
]  =      0       ; a        =       0;            y(    b  [
 a +  8  *3   *  5  ] )  {   d  [ a  ]   = a  [    d] +  !  !( b[
a+ 40  *  3     ]  -4  * 8) *  2    ;      ++  a   ;   }     a  =
 0       ;      y  (     a     [  b +      6          *  40 ]
)  {a [d ]  +=  !   !  ( b[ a   +    5 *  6  *    8  ] - 4   *
 8        ) *  4;   a =   a  + 1    ;} a=   0;   y  (a   <3 *8
   *5       )  {    r    (     a    [       d    ]  )    {  e
 =  1  ; y    (   e[ a  +  d] ){    *  ( d+ a+    e )   = a[ d
+e -  1] +(       d   [     a  +   e  ]  <<  (   3* e) )     ;e
 =    e           +  1  ;} a       =        a     +
e -  1     ; v( !! (  *  (  d+
  a)  %   (  64  )  - 12  *  5
  )             +  (  e
>  4   ) ?t [   e   >2 ?  2  :a    [ d   ]  ]   :6 *  8  +( t  [ d[
 a    ]/ 8     /8   ]  -4  )      %( 10 )  )    ;  r(  ! (2 [a
+  d] +  3  [d +       a  ]  )    )        v    (  4  *     8    )
 ;  }    a =   a  + 1 ; } v    (5 *  2     )  ;  }    z {c =b ;   e
=  0    ;     y  (*   c )  {   *   c +=   -  (* c    >   8 *     12
   )    *  32    ;      a         =  8       *  8       ;  r  (* c
 >=  48  &&*  c<8  *8   -6)  {*c  =(   * c  + 1
 )   %(  5    * 2  ) +  65   ;y(  --a  >0   &&*
c-  a[  t]   );   d[   (e   ++   )]   =4   ;(
 * (  d +  (e   ++)  ))=  07   ;}z  y(a  --  >1
 &&*  c-   t[a  ]);  d[   ( e  = e  +    1)  -
1]   =a   %8   ;y   (a   /=   8)   d[   (e  ++
 ) ]  =    a% 8   ; ++ c   ; *  (   e ++   +d )  =0
;} --  e   ;r    (         e >0  ) {a  =   1   ;
y          (  a<       8     )  {   c =       b  ;y
 ( c  <e +b  )   {  v  (  *     ( c  -    b + d  )&   a? 6  *7
:8       *  4     ) ;   c ++   ;} a=  a   +    a  ;    v  ( 2*
   5) ;  }  v    (  5*    2    )          ;   }} }}      }

בעין בלתי מזויינת זה נראה כמו גיבריש

והסיבה שהעלתי את זה זה בגלל שאני ממש רוצה לדעת, מה לעז*זל השורה הזו עושה:

#define t " A?B?K?L?CIF?MSP?E?H?O?R?DJG?NTQ?????U?V?????X???????Z????W??Y??"

ואגב זו באמת תוכנית שעובדת, תנסו בעצמכם...

חכה אני אגיד לך. זה פשוט שימוש מרובה בMACROS

כל מה שצריך לעשות זה FIND REPLACE.

#include <stdio.h>

#define t " A?B?K?L?CIF?MSP?E?H?O?R?DJG?NTQ?????U?V?????X???????Z????W??Y??"
void main ()
{
	char *c, b[5*72];
	int a, e, d[9*9*9];
	while(gets(b))
	{
		if(0[b]-7*5)
		{
			c=b;
			while((*c-6*7)**c)
				c=c+1;
			if((-0)[c] && gets(b+8*5*3 && gets(b+8*5*6))
			{
				a=0;
				while(a[b])
				{
					a[d]=!!(a[b]-4*8);
					a=a+1;
				}
				while(a<8*5*3)
					d[(a++)]=0;
				a=0;
				while(b[a+8*3*5])
				{
					d[a]=a[d]+!!(b[a+40*3]-4*8)*2;
					++a;
				}
				a=0;
				while(a[b+6*40])
				{
					a[d]+=!!(b[a+5*6*8]-4*8)*4;
					a=a+1;
				}
				a=0;
				while(a<3*8*5)
				{
					if(a[d])
					{
						e=1;
						while(e[a+d])
						{
							*(d+a+e)=a[d+e-1]+(d[a+e]<<(3*e));
							e=e+1;
						}
						a=a+e-1;
						putchar(!!(*(d+a)%(64)-12*5)+(e>4)?t[e>2?2:a[d]]:6*8+(t[d[a]/8/8]-4)%(10));
						if(!(2[a+d]+3[d+a]))
							putchar(4*8);
					}
					a=a+1;
				}
				putchar(5*2);
			}
			else
			{
				c=b;
				e=0;
				while(*c)
				{
					*c+=-(*c>8*12)*32;
					a=8*8;
					if(*c>=48 && *c<8*8-6)
					{
						*c=(*c+1%(5*2)+65;
						while(--a>0 && *c-a[t]);
						d[(e++)]=4;
						(*(d+(e++)))=07;
					}
					else
						while(a-->1 && *c-t[a]);
					d[(e=e+1)-1]=a%8;
					while(a/=8)
						d[(e++)]=a%8;
					++c;
					*(e++ +d)=0;
				}
				--e;
				if(e>0)
				{
					a=1;
					while(a<8)
					{
						c=b;
						while(c<e+b)
						{
							putchar(*(c-b+d)&a?6*7:8*4);
							c++;
						}
						a=a+a;
						putchar(2*5);
					}
					putchar(5*2);
				}
			}
		}
	}
}

שמעו זה מקצר מאוד את הקוד.

זה באמת מקצר את הקוד...

אבל אני עדיין לא מבין את המאקרו הזה

#define t " A?B?K?L?CIF?MSP?E?H?O?R?DJG?NTQ?????U?V?????X???????Z????W??Y??"

יש פה יותר מידי סימני שאלה בשבילי...

זה טריק נחמד, משתמשים בו גם באחד השלבים ב try2hack.nl

במקום לכתוב תווים כמו 'A' או 'C' אז הם ניגשים למערך התווים t (שזה בעצם מה שנוצר) ולוקחים ממנו. נגיד

t[1]

הוא A ו

t[3]

הוא C

לדוגמא בשורה:

putchar(!!(*(d+a)%(64)-12*5)+(e>4)?t[e>2?2:a[d]]:6*8+(t[d[a]/8/8]-4)%(10));

זה טריק נחמד, משתמשים בו גם באחד השלבים ב try2hack.nl

במקום לכתוב תווים כמו 'A' או 'C' אז הם ניגשים למערך התווים t (שזה בעצם מה שנוצר) ולוקחים ממנו. נגיד 

t[1]

הוא A  ו

t[3]

הוא C

לדוגמא בשורה:

putchar(!!(*(d+a)%(64)-12*5)+(e>4)?t[e>2?2:a[d]]:6*8+(t[d[a]/8/8]-4)%(10));

טריק מגניב, אבל זו לא הסיבה ש-t בנויה ככה. ל-t יש תפקיד חשוב בתכנית, והיא לא נועדה סתם להקשות עלינו...

תכנית חביבה למדי. (אזהרת ספוילר)

לאחר מאמץ (לא, בלי קימפול והרצה) נראה לי שהבנתי מה היא עושה - מאותיות (וספרות) לכתב ברייל ולהיפך.

התכנית עוברת שורה שורה בקלט. אם היא מוצאת כוכביות, אז היא מניחה שמדובר בשורת ברייל (ליתר דיוק 3 שורות) ומתרגמת אותה לאותיות. לא התעמקתי בחלק הזה של הקוד, כי הוא די מסובך (אני מנחש מה הוא עושה, בהתאם לחלק האחר...)

אם היא לא מוצאת כוכביות, היא מניחה שמדובר בשורת אותיות (וספרות), ומתרגמת לברייל.

זה נעשה באמצעות t, שהיא בעצם טבלת תרגום מאותיות לברייל. אפשר להבין את זה לפי הטבלה הזו:

http://www.cnib.ca/school-package/images/br_alpha.gif

כל אות ברייל היא 6 נקודות, שזה הרי שקול למספר בן 6 ביט (כלומר בין 0 ל-63, שזה בדיוק גודלו של t)

מגניב, לא?

מגניב למדי באמת לא הבנתי למה הם סידרו את זה ככה, חשבתי שאולי הם מערבלים את הביטים או משהו כזה.

קבל ח"ח. התמונה (כשמתרגמים אותה לביטים) באמת יוצאת תואמת. לפחות A ו C שבדקתי מקודם.

אבל נראה אם תבינו למה אין ב-t בכלל ספרות (ובכל זאת התכנית תדע לתרגם ספרות).

אמרו כבר שזה ב6BIT ולא ב8, ולכן חלק מהתווים אתה לא רואה(?). אם תשימו לב, יש שם >> ו << שאלו פקודות לטיפול בביטים.

לא מדויק.

הטבלה t מכילה רק 64 ערכים, שביניהם A-Z (והשאר הם רווח וסימני שאלה).

אם ננסה לגשת למקום יותר גדול מ-63 ב-t נגרום ל-overflow, ולא נקבל ספרות אלא נקבל סימנים לא צפויים (כנראה סתם זבל שיושב בזכרון).

התשובה לשאלה שלי נובעת מהדרך לייצג ספרות בכתב ברייל (נו אנשים, תעשו חיפוש קצר בגוגל).

ממה שאני זוכר (הסתכלתם פעם טוב על כפתורים של מעליות מסוימות?) מספרים בברייל הם די מסודרים (אני לא זוכר בדיוק אם זה בסיס 4 או שזה ממש בינארי)

http://en.wikipedia.org/wiki/Braille

ושוב מגיעה IceBreak עם בויקיפדיה ומציל את כולם

בהתבוננות קטנה בטבלה שנתת מקודם, אני מניח זנק עוברות למה שהן עוברות(נק למטה) כאשר 5 זה 2^5 ו- 0 זה 5^0.

ולזה מוסיפים נראה לי 94 או 120 (תלוי אם צריך קטן או גדול). עכשיו שאני חושב על זה זה נורא נחמד...

עריכה: והתמונה:

עריכה 2: טו ב לא ראיתי את העמוד השני, אבל הייתי קרוב.

[attachment deleted by admin]