fork download
copy 
  1. #include <stdio.h>
  2.  
  3. int main( void ) 
  4. {
  5. 	char myString[] = "1, 1.0, 1.000, 1.0000";
  6. 	struct myStruct
  7. 	{
  8. 		int I1;
  9. 		double D1;
  10. 		double D2; double D3;
  11. 	} myStruct;
  12.  
  13. 	sscanf( myString, "%d ,%lf ,%lf ,%lf", 
  14. 	        &myStruct.I1,&myStruct.D1, &myStruct.D2, &myStruct.D3 );
  15.  
  16. 	printf( "%d, %.1f, %.2f, %.3f\n", myStruct.I1, myStruct.D1, myStruct.D2, myStruct.D2 );
  17.  
  18. 	return 0;
  19. }
  20.  
  21. /*
  22. #include <iostream>
  23. #include <utility>
  24.  
  25. template <typename UnaryPredicate>
  26. void conditional_bubble_sort( int a[], size_t n, 
  27.                               UnaryPredicate &&unary_predicate,
  28.                               bool order = false )
  29. {
  30. 	while ( n && !unary_predicate( *a ) )
  31. 	{
  32. 		++a;
  33. 		--n;
  34. 	}
  35.  
  36. 	for ( size_t i = 0, last = 0; !( n < 2 ); n = last )
  37. 	{
  38. 		last = 0;
  39.  
  40. 		for ( size_t current = 0, next = 0; next < n; current = next )
  41. 		{
  42. 			while ( ++next < n && !unary_predicate( a[next] ) );
  43.  
  44. 			if ( next != n )
  45. 			{
  46. 				if ( !order ? a[next] < a[current] : a[current] < a[next] )
  47. 				{
  48. 					std::swap( a[current], a[next] );
  49. 					last = next;
  50. 				}
  51. 			}
  52. 		}
  53. 	}
  54. }
  55.  
  56. int main() 
  57. {
  58. //	int a[] = { 5, 2, 4, 3, 1 };
  59. 	int a[] = { 9, 0, 7, 2, 5, 4, 3, 6, 1, 8 };
  60. 	const size_t N = sizeof( a ) / sizeof( *a );
  61.  
  62. 	for ( const auto &item : a )
  63. 	{
  64. 		std::cout << item << ' ';
  65. 	}
  66. 	std::cout << '\n';
  67.  
  68. 	conditional_bubble_sort( a, N, []( const auto &item ) { return item % 2 != 0;} );
  69.  
  70. 	for ( const auto &item : a )
  71. 	{
  72. 		std::cout << item << ' ';
  73. 	}
  74. 	std::cout << '\n';
  75.  
  76. 	conditional_bubble_sort( a, N, []( const auto &item ) { return item % 2 == 0;}, true );
  77.  
  78. 	for ( const auto &item : a )
  79. 	{
  80. 		std::cout << item << ' ';
  81. 	}
  82. 	std::cout << '\n';
  83.  
  84. 	return 0;
  85. }
  86. */
  87. /*
  88. #include <iostream>
  89. #include <iomanip>
  90. #include <cstring>
  91.  
  92. int stringcompare( const char ( * *( int * s1, const char *s2, sin )
  93. {
  94.     while ( n && *s1 && *s1 == *s2 )
  95.     {
  96.         ++s1;
  97.         ++s2;
  98.         --n;
  99.     }
  100.  
  101.     return n == 0 ? 0 : *s1 - *s2;
  102. }
  103.  
  104. int main() 
  105. {
  106. 	const char *s1 = "Hello";
  107. 	const char *s2 = "Hello World";
  108.  
  109. 	std::cout << std::strncmp( s1, s2, 100 ) << '\n';
  110. 	std::cout << std::strncmp( s1, s2, 0 ) << '\n';
  111. 	std::cout << std::strncmp( s1, s2, 5 ) << '\n';
  112. 	std::cout << std::strncmp( s1, s2, 6 ) << '\n';
  113.  
  114. 	std::cout << '\n';
  115.  
  116. 	std::cout << stringcompare( s1, s2, 100 ) << '\n';
  117. 	std::cout << stringcompare( s1, s2, 0 ) << '\n';
  118. 	std::cout << stringcompare( s1, s2, 5 ) << '\n';
  119. 	std::cout << stringcompare( s1, s2, 6 ) << '\n';
  120.  
  121. 	return 0;
  122. }
  123. */
  124. /*
  125. #include <iostream>
  126. #include <list>
  127. #include <iterator>
  128. #include <algorithm>
  129.  
  130. template <typename T>
  131. std::list<T> merge_lists( std::list<T> &list1, std::list<T> &list2 )
  132. {
  133. 	std::list<T> list3;
  134.  
  135. 	typename std::list<T>::iterator first1 = std::begin( list1 ),
  136. 	                                first2 = std::begin( list2 );
  137. 	typename std::list<T>::iterator last1  = std::end( list1 ),
  138. 	                                last2  = std::end( list2 );
  139.  
  140. 	while ( first1 != last1 && first2 != last2 )	                                
  141. 	{
  142. 		if ( *first2 < *first1 )
  143. 		{
  144. 			list3.push_back( *first2 );
  145. 			first2 = list2.erase( first2 );
  146. 		}
  147. 		else
  148. 		{
  149. 			list3.push_back( *first1 );
  150. 			first1 = list1.erase( first1 );
  151. 		}
  152. 	}
  153.  
  154. 	list3.insert( std::end( list3 ), first1, last1 );
  155. 	list1.erase( first1, last1 );
  156.  
  157. 	list3.insert( std::end( list3 ), first2, last2 );
  158. 	list2.erase( first2, last2 );
  159.  
  160. 	return list3;
  161. }
  162.  
  163. int main()
  164. {
  165. 	std::list<int> list1 = { 1, 3, 5 };
  166. 	std::list<int> list2 = { 0, 2, 4 };
  167.  
  168.     std::list<int> list3;
  169.     
  170.     std::merge( std::begin( list1 ), std::end( list1 ),
  171.                 std::begin( list2 ), std::end( list2 ),
  172.                 std::back_inserter( list3 ) );
  173.                 
  174. //	std::list<int> list3 = merge_lists( list1, list2 );
  175.  
  176.  
  177. 	for ( const auto &item : list3 )
  178. 	{
  179. 		std::cout << item << ' ';
  180. 	}
  181.  
  182. 	std::cout << '\n';
  183.  
  184. 	std::cout << list1.empty() << '\n';
  185. 	std::cout << list2.empty() << '\n';
  186. }
  187.  
  188.  
  189. #include <iostream>
  190. #include <utility>
  191.  
  192. using cell = int;
  193.  
  194. int main() 
  195. {
  196. 	using cell = std::pair<void *, cell *>;
  197.  
  198. 	return 0;
  199. }
  200. */
  201.  
  202. /*
  203. #include <stdio.h>
  204. #include <ctype.h>
  205. #include <stdlib.h>
  206. #include <string.h>
  207.  
  208. char * partition( char *s )
  209. {
  210. 	while ( *s && isdigit( ( unsigned char )*s ) ) ++s;
  211.  
  212. 	char *p = s;
  213.  
  214. 	while ( *s++ )
  215. 	{
  216. 		if ( isdigit( ( unsigned char )*s ) )
  217. 		{
  218. 			char c = *p;
  219. 			*p++ = *s;
  220. 			*s = c;
  221. 		}
  222. 	}
  223.  
  224. 	return p;
  225. }
  226.  
  227. int cmp( const void *a, const void *b )
  228. {
  229. 	return *( const unsigned char * )a - *( const unsigned char * )b;
  230. }
  231.  
  232. int main(void) 
  233. {
  234. 	char s[] = "38ch50ej16af49di27bg";
  235.  
  236. 	puts( s );
  237.  
  238. 	char *p = partition( s );
  239.  
  240. 	qsort( s, p - s, sizeof( char ), cmp );
  241. 	qsort( p, strlen( p ), sizeof( char ), cmp );
  242.  
  243. 	puts( s );
  244.  
  245. 	return 0;
  246. }
  247. */
  248.  
  249. /*
  250. #include <stdio.h>
  251.  
  252. int even( unsigned int );
  253. int odd( unsigned int x )
  254. {
  255. 	if ( x ) return even( x - 1 );
  256. 	return 0;
  257. } 
  258.  
  259. int even( unsigned int x )
  260. {
  261. 	if ( x ) return odd( x - 1 );
  262. 	return 1;
  263. }
  264.  
  265. int main(void) 
  266. {
  267. 	printf( "odd( 1 ) = %d , even( 1 ) = %d\n", odd( 1 ), even( 1 ) );
  268. 	printf( "odd( 2 ) = %d , even( 2 ) = %d\n", odd( 2 ), even( 2 ) );
  269.  
  270. 	return 0;
  271. }
  272. */
  273. /*
  274. #include <iostream>
  275. #include <vector>
  276. #include <iterator>
  277.  
  278. int main() 
  279. {
  280. 	std::vector<int> datas = { 10, 5, 6, 8 };
  281. 	std::vector<int> index = { 0, 2 };
  282.  
  283. 	std::vector<int>::size_type i = 0;
  284.  
  285. 	for ( const auto &pos : index )
  286. 	{
  287. 		if ( pos - i < datas.size() )
  288. 		{
  289. 			datas.erase( std::next( std::begin( datas ), pos - i++ ) );
  290. 		}
  291. 		else
  292. 		{
  293. 			break;
  294. 		}
  295. 	}
  296.  
  297. 	for ( const auto &item : datas )
  298. 	{
  299. 		std::cout << item << ' ';
  300. 	}
  301. 	std::cout << '\n';
  302.  
  303. 	return 0;
  304. }
  305. */
  306. /*
  307. #include <stdio.h>
  308. #include <stdlib.h>
  309.  
  310. struct node 
  311. {
  312. 	int data;
  313. 	struct node *next;
  314. 	struct node *prev;
  315. };
  316.  
  317. struct list
  318. {
  319. 	struct node *head;
  320. 	struct node *tail;
  321. };
  322.  
  323. int append( struct list *list, int data )
  324. {
  325. 	struct node *node = malloc( sizeof( *node ) );
  326. 	int success = node != NULL;
  327.  
  328. 	if ( success )
  329. 	{
  330. 		node->data = data;
  331. 		node->prev = list->tail;
  332. 		node->next = NULL;
  333.  
  334. 		if ( list->tail == NULL )
  335. 		{
  336. 			list->head = node;
  337. 		}
  338. 		else
  339. 		{
  340. 			list->tail->next = node;
  341. 		}
  342.  
  343. 		list->tail = node;
  344. 	}
  345.  
  346. 	return success;
  347. }
  348.  
  349. FILE * display( const struct list *list, FILE *fp )
  350. {
  351. 	for ( const struct node *current = list->head; current != NULL; current = current->next )
  352. 	{
  353. 		fprintf( fp, "%d -> ", current->data );
  354. 	}
  355.  
  356. 	fputs( "null", fp );
  357.  
  358. 	return fp;
  359. }
  360.  
  361. FILE * reverse_display( const struct list *list, FILE *fp )
  362. {
  363. 	for ( const struct node *current = list->tail; current != NULL; current = current->prev )
  364. 	{
  365. 		fprintf( fp, "%d -> ", current->data );
  366. 	}
  367.  
  368. 	fputs( "null", fp );
  369.  
  370. 	return fp;
  371. }
  372.  
  373.  
  374. int check_prime( int n )
  375. {
  376. 	int prime = n % 2 == 0 ? n == 2 : n != 1;
  377.  
  378. 	for ( int i = 3; prime && i <= n / i; i += 2 )
  379. 	{
  380. 		prime = n % i != 0;
  381. 	}
  382.  
  383. 	return prime;
  384. }
  385.  
  386. void delete_prime_number( struct list *list )
  387. {
  388. 	struct node **head = &list->head;
  389.  
  390.     while ( *head != NULL )
  391.     {
  392.         if ( check_prime( ( *head )->data ) )
  393.         {
  394.             struct node *tmp = *head;
  395.  
  396.             if ( ( *head )->next != NULL )
  397.             {
  398.                 ( *head )->next->prev = ( *head )->prev;
  399.             }
  400.             else
  401.             {
  402.             	list->tail = ( *head )->prev;
  403.             }
  404.             
  405.             *head = ( *head )->next;
  406.              
  407.             free( tmp );
  408.         }
  409.         else
  410.         {
  411.             head = &( *head )->next;
  412.         }
  413.     }	
  414. }
  415.  
  416. int main(void) 
  417. {
  418. 	struct list list = { .head = NULL, .tail = NULL };
  419. 	const int N = 14;
  420.  
  421. 	for ( int i = 0; i < N; i++ )
  422. 	{
  423. 		append( &list, i );
  424. 	}
  425.  
  426. 	fputc( '\n', display( &list, stdout ) );
  427. 	fputc( '\n', reverse_display( &list, stdout ) );
  428.  
  429. 	delete_prime_number( &list );
  430.  
  431. 	fputc( '\n', display( &list, stdout ) );
  432. 	fputc( '\n', reverse_display( &list, stdout ) );
  433.  
  434. 	return 0;
  435. }
  436. */
  437. /*
  438. #include <iostream>
  439. #include <utility>
  440. #include <vector>
  441. #include <map>
  442. #include <iterator>
  443. #include <algorithm>
  444.  
  445. std::pair<std::vector<char>::const_iterator, std::vector<char>::size_type>
  446. getMostFrequentElement( const std::vector<char> &v )
  447. {
  448. 	std::pair<std::vector<char>::const_iterator, std::vector<int>::size_type> 
  449. 	result( std::end( v ), 0 );
  450.  
  451. 	std::map<char, size_t> m;
  452.  
  453.  
  454. 	for ( const auto &c : v ) ++m[c];
  455.  
  456. 	auto it = std::max_element( std::begin( m ), std::end( m ), 
  457. 	                            []( const auto &p1, const auto &p2 )
  458. 	                            {
  459. 	                            	return p1.second < p2.second;
  460. 	                            } );
  461.  
  462. 	if ( it != std::end( m ) )
  463. 	{
  464. 		result.first = std::find( std::begin( v ), std::end( v ), it->first );
  465. 		result.second = it->second;
  466. 	}
  467.  
  468. 	return result;
  469. }
  470.  
  471. std::vector<char> getMostFrequentElement( const std::vector<char> &v )
  472. {
  473. 	std::vector<char> result;
  474.  
  475. 	std::map<char, size_t> m;
  476.  
  477.  
  478. 	for ( const auto &c : v ) ++m[c];
  479.  
  480. 	auto it = std::max_element( std::begin( m ), std::end( m ), 
  481. 	                            []( const auto &p1, const auto &p2 )
  482. 	                            {
  483. 	                            	return p1.second < p2.second;
  484. 	                            } );
  485.  
  486. 	if ( it != std::end( m ) )
  487. 	{
  488. 		for ( const auto &p : m )
  489. 		{
  490. 			if ( p.second == it->second ) result.push_back( p.first );
  491. 		}
  492. 	}
  493.  
  494. 	return result;
  495. }
  496.  
  497. int main() 
  498. {
  499. 	std::vector<char> v = { 'a', 'a', 'b', 'b', 'c' };
  500.  
  501. 	auto p = getMostFrequentElement( v );
  502.  
  503. 	std::cout << *p.first << ": " << p.second<< '\n';
  504.  
  505. 	auto result = getMostFrequentElement( v );
  506.  
  507. 	for ( const auto &c : result ) std::cout << c << ' ';
  508. 	std::cout << '\n';
  509.  
  510. 	return 0;
  511. }
  512.  
  513. #include <stdio.h>
  514. #include <stdlib.h>
  515. #include <string.h>
  516.  
  517. struct Node
  518. {
  519. 	int data;
  520. 	struct Node *next;
  521. } typedef Node;
  522.  
  523. FILE * display( const Node *head, FILE *fp )
  524. {
  525. 	for ( ; head != NULL; head = head->next )
  526. 	{
  527. 		fprintf( fp, "%d -> ", head->data );
  528. 	}
  529.  
  530. 	fputs( "null", fp );
  531.  
  532. 	return fp;
  533. }
  534.  
  535. void adjacent_swap( Node **node )
  536. {
  537. 	Node *tmp = *node;
  538. 	*node = ( *node )->next;
  539. 	tmp->next = ( *node )->next;
  540. 	( *node )->next = tmp;
  541. }
  542.  
  543. void bubble_sort( Node **head )
  544. {
  545. 	for ( Node *last = NULL, *sorted = NULL; *head && ( *head )->next != last; last = sorted )
  546. 	{
  547. 		sorted = ( *head )->next;
  548.  
  549. 		for ( Node **current = head; ( *current )->next != last; current = &( *current )->next )
  550. 		{
  551. 			if ( ( *current )->next->data < ( *current )->data )
  552. 			{
  553. 				adjacent_swap( current );
  554. 				sorted = ( *current )->next;
  555. 			}
  556. 		}
  557. 	}
  558. }
  559.  
  560. int main(void) 
  561. {
  562. 	Node *head = malloc( sizeof( Node ) );
  563. 	head->data = 2;
  564. 	head->next = malloc( sizeof( Node ) );
  565. 	head->next->data = 1;
  566. 	head->next->next = NULL;
  567.  
  568. 	fputc( '\n', display( head, stdout ) );
  569.  
  570. 	bubble_sort( &head );
  571.  
  572. 	fputc( '\n', display( head, stdout ) );
  573.  
  574. 	int num1 = 1, num2 = 2, num3 = 3;
  575.  
  576. 	if ( !( num1 < num2 ) && !( num1 < num3 ) )
  577. 	{
  578. 		puts( "First Number Is The Largest" );
  579. 	}
  580. 	if ( !( num2 < num3 ) )
  581. 	{
  582. 		puts( "Second Number Is The Largest" );
  583. 	}
  584. 	else
  585. 	{
  586. 		puts( "Third Number Is The Largest" );
  587. 	}
  588. 	return 0;
  589. }
  590. */
  591.  
  592.  
Success #stdin #stdout 0s 5524KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
1, 1.0, 1.00, 1.000
https://ideone.com/NbTP1y
language:
C++14 (gcc 8.3)
created:
2 years ago
visibility:
public

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!