API tools faq
paste
Advertisement
Aiaa

Untitled

Aiaa
May 3rd, 2016
57
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 17.02 KB | None | 0 0
raw download clone embed print report
  1. import java.io.File;
  2. import java.util.Formatter;
  3. import java.util.LinkedList;
  4. import java.util.Scanner;
  5. import java.util.Stack;
  6.  
  7. public class Classy {
  8. static int nOfBits = 0;
  9. static int noRemain = 0;
  10. static StringBuilder inputstr = new StringBuilder();
  11. static StringBuilder dontcarestr = new StringBuilder();
  12. static LinkedList<Nody> array[];
  13. static LinkedList<Nody> remain;
  14. static LinkedList<Nody> finall_array;
  15. static int arraysize = 0;
  16. static int minterms[];
  17. static boolean file = false;
  18. static Formatter writefile ;
  19. static void printDebug(String s) {
  20. if (file) {
  21. writefile.format("%s\n",s);
  22. }
  23. else {
  24. System.out.println(s);
  25.  
  26. }
  27. }
  28.  
  29. static void binary(int decimal) {
  30.  
  31. StringBuilder conc = new StringBuilder();
  32. String bin = Integer.toBinaryString(decimal);
  33. int count = 0;
  34. for (int i = 0; i < bin.length(); i++) {
  35. if (bin.charAt(i) == '1') {
  36. count++;
  37. }
  38. }
  39. for (int i = 0; i < nOfBits - bin.length(); i++) {
  40. conc.append("0");
  41. }
  42. conc.append(bin);
  43. printDebug(conc.toString());
  44. int de = (int) Math.pow(2, nOfBits) - 1;
  45. printDebug("" + de);
  46. Nody new_node = new Nody((int) Math.pow(2, nOfBits) - 1);
  47. new_node.minterm = conc.toString();
  48. printDebug(new_node.minterm);
  49. // new_node.min[decimal] = true;
  50. String s = Integer.toString(decimal);
  51. if (new_node.symbol == null) {
  52. new_node.symbol = s;
  53. } else {
  54. new_node.symbol += s;
  55. }
  56. // new_node.symbol += s ;
  57. new_node.symbol += ",";
  58. // new_node.symbol.append(Integer.toString(decimal)).append(',');
  59. printDebug(new_node.symbol);
  60. int nOfOnes = 0;
  61. for (int i = 0; i < new_node.minterm.length(); i++) {
  62. if (new_node.minterm.charAt(i) == '1') {
  63. nOfOnes++;
  64. }
  65. }
  66. if (array[nOfOnes] == null) {
  67. array[nOfOnes] = new LinkedList();
  68. }
  69.  
  70. array[nOfOnes].add(new_node);
  71.  
  72. }
  73.  
  74. public static void solve(LinkedList<Nody> tmp[]) {
  75.  
  76. LinkedList<Nody> tmpnext = new LinkedList<Nody>();
  77. int i = 0;
  78. while (i < nOfBits) {
  79. LinkedList<Nody> no = tmp[i];
  80. LinkedList<Nody> no2 = tmp[i + 1];
  81. if (no == null || no2 == null) {
  82. i++;
  83. continue;
  84.  
  85. }
  86. int n = no.size();
  87. int n2 = no2.size();
  88. int del1 = 0;
  89. int del2 = 0;
  90. for (int j = 0; j < n; j++) {
  91. int take = 0;
  92. for (int k = 0; k < tmp[i + 1].size(); k++) {
  93. if (tmp[i + 1].get(k) == null) {
  94. continue;
  95.  
  96. }
  97. if (tmp[i].get(j) == null) {
  98. continue;
  99.  
  100. }
  101.  
  102. int count = 0;
  103. String newminterm = new String();
  104. for (int l = 0; l < nOfBits; l++) {
  105. printDebug(tmp[i].get(j).minterm);
  106. printDebug(tmp[i + 1].get(k).minterm);
  107. printDebug("" + tmp[i].get(j).minterm.charAt(l));
  108. printDebug("" + tmp[i + 1].get(k).minterm.charAt(l));
  109. if (tmp[i].get(j).minterm.charAt(l) == tmp[i + 1].get(k).minterm.charAt(l)) {
  110. if (newminterm == null) {
  111. newminterm = "" + tmp[i].get(j).minterm.charAt(l);
  112. } else {
  113. newminterm += "" + tmp[i].get(j).minterm.charAt(l);
  114. }
  115. // newminterm.append(tmp[i].get(j).minterm.charAt(l));
  116. printDebug(newminterm);
  117. continue;
  118.  
  119. } else {
  120. count++;
  121. if (newminterm == null) {
  122. newminterm = "-";
  123. } else {
  124. newminterm += "-";
  125. }
  126. printDebug(newminterm);
  127. // newminterm.append('-');
  128. if (count > 1)
  129. break;
  130.  
  131. }
  132. }
  133. if (count == 1) {
  134. Nody new_node = new Nody(nOfBits);
  135. new_node.minterm = newminterm;
  136. new_node.min[i] = true;
  137.  
  138. if (new_node.symbol == null) {
  139. new_node.symbol = tmp[i].get(j).symbol;
  140. // new_node.symbol += ",";
  141. new_node.symbol += tmp[i + 1].get(k).symbol;
  142. // new_node.symbol += ",";
  143. } else {
  144. new_node.symbol += tmp[i].get(j).symbol;
  145. // new_node.symbol += ",";
  146. new_node.symbol += tmp[i + 1].get(k).symbol;
  147. // new_node.symbol += ",";
  148. }
  149. printDebug(new_node.minterm);
  150. printDebug(new_node.symbol);
  151. // new_node.symbol.append(Integer.toString(i)).append(',').append(Integer.toString(i
  152. // + 1))
  153. // .append(',');
  154.  
  155. tmpnext.add(new_node);
  156. take = 1;
  157. }
  158.  
  159. }
  160. if (take == 0) {
  161. Nody new_node = new Nody(nOfBits);
  162. new_node.minterm = tmp[i].get(j).minterm;
  163. if (new_node.symbol == null) {
  164. new_node.symbol = tmp[i].get(j).symbol;
  165.  
  166. } else {
  167. new_node.symbol += tmp[i].get(j).symbol;
  168.  
  169. }
  170. // new_node.symbol.append(Integer.toString(i)).append(',');
  171. if (remain == null) {
  172. remain = new LinkedList<Nody>();
  173. }
  174. remain.add(new_node);
  175. for (int l = 0; l < remain.size(); l++) {
  176. // printDebug("remain ya yoyo");
  177. printDebug(remain.get(l).minterm);
  178. printDebug(remain.get(l).symbol);
  179. }
  180. //
  181. noRemain++;
  182. }
  183. }
  184. i++;
  185. }
  186. getdashes(tmpnext);
  187.  
  188. }
  189.  
  190. public static void getdashes(LinkedList<Nody> dash) {
  191.  
  192. LinkedList<Nody> tmpdash = new LinkedList<Nody>();
  193. boolean check_ind[] = new boolean[dash.size()];
  194. printDebug(Integer.toString(dash.size()));
  195. for (int i = 0; i < dash.size(); i++) {
  196.  
  197. int take = 0;
  198. if (check_ind[i] == true) {
  199. continue;
  200. }
  201. for (int j = 0; j < dash.size(); j++) {
  202. if (i == j) {
  203. continue;
  204. }
  205. printDebug(dash.get(i).minterm);
  206. printDebug(dash.get(i).symbol);
  207. printDebug(dash.get(j).minterm);
  208. printDebug(dash.get(j).symbol);
  209. int count = 0;
  210.  
  211. String newminterm = new String();
  212. for (int l = 0; l < nOfBits; l++) {
  213.  
  214. if (dash.get(j).minterm.charAt(l) == dash.get(i).minterm.charAt(l)) {
  215. if (newminterm == null) {
  216. newminterm = "" + dash.get(j).minterm.charAt(l);
  217. } else {
  218. newminterm += "" + dash.get(j).minterm.charAt(l);
  219. }
  220. // newminterm.append(dash.get(j).minterm.charAt(l));
  221. printDebug(newminterm);
  222. continue;
  223.  
  224. } else {
  225. count++;
  226. if (newminterm == null) {
  227. newminterm = "-";
  228. } else {
  229. newminterm += "-";
  230. }
  231. printDebug(newminterm);
  232. // newminterm.append('-');
  233. if (count > 1)
  234. break;
  235.  
  236. }
  237. }
  238. if (count == 1) {
  239. int add = 1;
  240. Nody new_node = new Nody(nOfBits);
  241. new_node.minterm = newminterm;
  242. if (new_node.symbol == null) {
  243. new_node.symbol = dash.get(i).symbol;
  244. new_node.symbol += dash.get(j).symbol;
  245.  
  246. // new_node.symbol += ",";
  247.  
  248. } else {
  249. new_node.symbol += dash.get(i).symbol;
  250. new_node.symbol += dash.get(j).symbol;
  251. // new_node.symbol += ",";
  252.  
  253. }
  254. printDebug(new_node.symbol);
  255. printDebug(new_node.minterm);
  256. // new_node.symbol.append(dash.get(i).symbol).append(dash.get(j).symbol).append(',');
  257. if (check_ind[j] == true) {
  258. if (new_node.minterm == dash.get(j).minterm)
  259. add = 0;
  260. }
  261. if (add == 1) {
  262. check_ind[j] = true;
  263. tmpdash.add(new_node);
  264. }
  265. take = 1;
  266. }
  267. }
  268. if (take == 0) {
  269. Nody new_node = new Nody(nOfBits);
  270. new_node.minterm = dash.get(i).minterm;
  271. new_node.symbol = dash.get(i).symbol;
  272. printDebug(new_node.minterm);
  273. printDebug(new_node.symbol);
  274. if (remain == null) {
  275. remain = new LinkedList<Nody>();
  276. }
  277. // remain.add(new_node);
  278. remain.add(new_node);
  279. noRemain++;
  280. }
  281.  
  282. }
  283. finall_array = tmpdash;
  284. // printDebug("tempy");
  285. for (int i = 0; i < tmpdash.size(); i++) {
  286. printDebug(tmpdash.get(i).symbol);
  287. printDebug(tmpdash.get(i).minterm);
  288. }
  289. if (tmpdash.size() != 0) {
  290.  
  291. getdashes(tmpdash);
  292. } else {
  293. int del = 0;
  294. // printDebug("final ya yOyo");
  295. for (int i = 0; i < remain.size(); i++) {
  296. if (remain.get(i).equals(null)) {
  297. remain.remove(i);
  298. // del++;
  299. // i--;
  300. }
  301.  
  302. }
  303. // for (int i = 0; i < remain.size(); i++) {
  304. // for (int k = 0; k < remain.size(); k++) {
  305. // if (i == k) {
  306. // continue;
  307. // }
  308. // if (remain.get(k).minterm.equals(remain.get(i).minterm)) {
  309. // remain.remove(k);
  310. // }
  311. // }
  312. //
  313. // }
  314. // printDebug("rem bef");
  315. printDebug("First final terms.");
  316. for (int i = 0; i < remain.size(); i++) {
  317. printDebug(remain.get(i).symbol);
  318. printDebug(remain.get(i).minterm);
  319. }
  320. // printDebug("rem af");
  321. // for (int i = 0; i < finall_array.size(); i++) {
  322. // printDebug(finall_array.get(i).symbol);
  323. // printDebug(finall_array.get(i).minterm);
  324. // }
  325. }
  326.  
  327. }
  328.  
  329. static int min = 4;
  330. static LinkedList<Nody> terms = new LinkedList<Nody>();
  331.  
  332. public static void allPossible(int index) {
  333. boolean[] takenterms = new boolean[(int) Math.pow(nOfBits, 2)];
  334. if (index == remain.size()) {
  335. return;
  336. }
  337. allPossible(index + 1);
  338. Nody temp = remain.get(index);
  339. terms.add(temp);
  340. Nody tempnode;
  341. for (int i = 0; i < terms.size(); i++) {
  342. tempnode = terms.get(i);
  343. String temparray[] = tempnode.symbol.split(",");
  344. for (int j = 0; j < temparray.length; j++) {
  345. takenterms[Integer.parseInt(temparray[j])] = true;
  346. }
  347. }
  348. for (int i = 0; i < minterms.length; i++) {
  349. if (!takenterms[minterms[i]]) {
  350. break;
  351. } else if (i == minterms.length - 1) {
  352. //// print terms hnaaaaaaaaa
  353. LinkedList<Nody> tempstack = terms;
  354. Nody current;
  355. if (tempstack.size() <= min) {
  356. min = tempstack.size();
  357. for (int j = 0; j < tempstack.size(); j++) {
  358. current = tempstack.get(j);
  359. for (int k = 0; k < current.minterm.length(); k++) {
  360. if (current.minterm.charAt(k) == '1') {
  361. if (file) {
  362. writefile.format("%c", 'A' + k);
  363. }
  364. else {
  365. System.out.print((char) ('A' + k));
  366. }
  367. } else if (current.minterm.charAt(k) == '0') {
  368. if (file) {
  369. writefile.format("%c'", 'A' + k);
  370. }
  371. else {
  372. System.out.print((char) ('A' + k) + "'");
  373. }
  374. }
  375. }
  376. if (j != tempstack.size() - 1) {
  377. if(file) {
  378. writefile.format("+");
  379. }
  380. else {
  381. System.out.print("+");
  382. }
  383. }
  384. }
  385. if(file) {
  386. writefile.format("\n");
  387. }
  388. else {
  389. System.out.println();
  390. }
  391. }
  392. terms.remove(terms.size() - 1);
  393. return;
  394. }
  395. }
  396. allPossible(index + 1);
  397. terms.remove(terms.size() - 1);
  398. }
  399.  
  400. public static void main(String[] args) {
  401. // TODO Auto-generated method stub
  402. /**
  403. * scan from file
  404. */
  405. Scanner scan = new Scanner(System.in);
  406. System.out.println("please choose \n1-from file\n2-from console");
  407. int x;
  408. while (true) {
  409. try {
  410. x = scan.nextInt();
  411. if (x != 1 && x != 2) {
  412. throw new RuntimeException();
  413. }
  414. break;
  415. } catch (Exception e) {
  416. System.out.println("wrong input, please try again");
  417. }
  418. }
  419. switch (x) {
  420. case 1:
  421. Scanner sc;
  422. try {
  423. file = true;
  424. writefile = new Formatter (new File ("result.txt"));
  425. sc = new Scanner(new File("aia.txt"));
  426. LinkedList<Integer> input = new LinkedList<Integer>();
  427. LinkedList<Integer> dontcare = new LinkedList<Integer>();
  428. int num = sc.nextInt();
  429. if (num < 0) {
  430. throw new RuntimeException();
  431. }
  432. int max = num;
  433. input.add(num);
  434. while (sc.hasNext()) {
  435. num = sc.nextInt();
  436. if (num == -1) {
  437. break;
  438. }
  439. if (num < 0) {
  440. throw new RuntimeException();
  441. }
  442. input.add(num);
  443. if (max < num) {
  444. max = num;
  445. }
  446. }
  447. if (num == -1) {
  448. while (sc.hasNext()) {
  449. num = sc.nextInt();
  450. if (num == -1) {
  451. break;
  452. }
  453. if (num < 0) {
  454. throw new RuntimeException();
  455. }
  456. dontcare.add(num);
  457. if (max < num) {
  458. max = num;
  459. }
  460. }
  461. }
  462. nOfBits = (int) (Math.log(max) / Math.log(2)) + 1;
  463. for (int i = 0; i < input.size(); i++) {
  464. for (int j = 0; j < i; j++) {
  465. if (input.get(i).equals(input.get(j))) {
  466. input.remove(j);
  467. j--;
  468. break;
  469. }
  470. }
  471. }
  472. for (int i = 0; i < dontcare.size(); i++) {
  473. for (int j = 0; j < i; j++) {
  474. if (dontcare.get(i).equals(dontcare.get(j))) {
  475. dontcare.remove(j);
  476. j--;
  477. break;
  478. }
  479. }
  480. }
  481. for (int i = 0; i < dontcare.size(); i++) {
  482. for (int j = 0; j < input.size(); j++) {
  483. if (input.get(j).equals(dontcare.get(i))) {
  484. throw new RuntimeException();
  485. }
  486. }
  487. }
  488.  
  489. for (int i = 0; i < input.size(); i++) {
  490. if (i == 0) {
  491. inputstr.append(input.get(i));
  492. } else {
  493. inputstr.append("," + input.get(i));
  494. }
  495. }
  496. for (int i = 0; i < dontcare.size(); i++) {
  497. if (i == 0) {
  498. dontcarestr.append(dontcare.get(i));
  499. } else {
  500. dontcarestr.append("," + dontcare.get(i));
  501. }
  502. }
  503. String inputString = inputstr.toString();
  504. String[] splitterInp = inputString.split(",");
  505.  
  506. array = new LinkedList[nOfBits + 1];
  507. for (int i = 0; i < splitterInp.length; i++) {
  508. int inty = Integer.parseInt(splitterInp[i]);
  509.  
  510. binary(inty);
  511. }
  512. String dontCareString = dontcarestr.toString();
  513. if (dontCareString.length() != 0) {
  514. String[] splitterDon = dontCareString.split(",");
  515. for (int i = 0; i < splitterDon.length; i++) {
  516. binary(Integer.parseInt(splitterDon[i]));
  517. }
  518.  
  519. }
  520. solve(array);
  521. minterms = new int[input.size()];
  522. for (int i = 0; i < input.size(); i++) {
  523. minterms[i] = input.get(i);
  524. }
  525. allPossible(0);
  526. writefile.close();
  527.  
  528. } catch (Exception e) {
  529. System.out.println("Fail to read from file OR wrong input");
  530. }
  531. break;
  532. /**
  533. * scan form console
  534. */
  535. // StringBuilder dontcarestr1 = new StringBuilder();
  536. // StringBuilder inputstr1 = new StringBuilder();
  537. case 2:
  538. Scanner sc1;
  539. System.out.println("enter the min terms");
  540. LinkedList<Integer> input1 = new LinkedList<Integer>();
  541. LinkedList<Integer> dontcare1 = new LinkedList<Integer>();
  542. try {
  543. sc1 = new Scanner(System.in);
  544. int num = sc1.nextInt();
  545. if (num < 0) {
  546. throw new RuntimeException();
  547. }
  548. int max = num;
  549. input1.add(num);
  550. while (true) {
  551. System.out.println("enter -1 to input dontcare:");
  552. num = sc1.nextInt();
  553. if (num == -1) {
  554. break;
  555. }
  556. if (num < 0) {
  557. throw new RuntimeException();
  558. }
  559. input1.add(num);
  560. if (max < num) {
  561. max = num;
  562. }
  563. }
  564. if (num == -1) {
  565. System.out.println("enter don't care");
  566.  
  567. while (true) {
  568. System.out.println("enter -1 to end: ");
  569. num = sc1.nextInt();
  570. if (num == -1) {
  571. break;
  572. }
  573. if (num < 0) {
  574. throw new RuntimeException();
  575. }
  576. dontcare1.add(num);
  577. if (max < num) {
  578. max = num;
  579. }
  580. }
  581. }
  582.  
  583. nOfBits = (int) (Math.log(max) / Math.log(2)) + 1;
  584. /// check repetition in min terms
  585. for (int i = 0; i < input1.size(); i++) {
  586. for (int j = 0; j < i; j++) {
  587. if (input1.get(i).equals(input1.get(j))) {
  588. input1.remove(j);
  589. j--;
  590. break;
  591. }
  592. }
  593. }
  594. //// check repetition in dontcare
  595. for (int i = 0; i < dontcare1.size(); i++) {
  596. for (int j = 0; j < i; j++) {
  597. if (dontcare1.get(i).equals(dontcare1.get(j))) {
  598. dontcare1.remove(j);
  599. j--;
  600. break;
  601. }
  602. }
  603. }
  604. /// check for repetition in min terms and dont care
  605. for (int i = 0; i < dontcare1.size(); i++) {
  606. for (int j = 0; j < input1.size(); j++) {
  607. if (input1.get(j).equals(dontcare1.get(i))) {
  608. throw new RuntimeException();
  609. }
  610. }
  611. }
  612.  
  613. for (int i = 0; i < input1.size(); i++) {
  614. if (i == 0) {
  615. inputstr.append(input1.get(i));
  616. } else {
  617. inputstr.append("," + input1.get(i));
  618. }
  619. }
  620. printDebug(inputstr.toString());
  621.  
  622. for (int i = 0; i < dontcare1.size(); i++) {
  623. if (i == 0) {
  624. dontcarestr.append(dontcare1.get(i));
  625. } else {
  626. dontcarestr.append("," + dontcare1.get(i));
  627. }
  628. }
  629. printDebug(dontcarestr.toString());
  630.  
  631. } catch (Exception e1) {
  632. System.out.println("wrong input");
  633. }
  634. String inputString = inputstr.toString();
  635. String[] splitterInp = inputString.split(",");
  636.  
  637. array = new LinkedList[nOfBits + 1];
  638. for (int i = 0; i < splitterInp.length; i++) {
  639. int inty = Integer.parseInt(splitterInp[i]);
  640.  
  641. binary(inty);
  642. }
  643. String dontCareString = dontcarestr.toString();
  644. if (dontCareString.length() != 0) {
  645. String[] splitterDon = dontCareString.split(",");
  646. for (int i = 0; i < splitterDon.length; i++) {
  647. binary(Integer.parseInt(splitterDon[i]));
  648. }
  649.  
  650. }
  651. solve(array);
  652. minterms = new int[input1.size()];
  653. for (int i = 0; i < input1.size(); i++) {
  654. minterms[i] = input1.get(i);
  655. }
  656. allPossible(0);
  657.  
  658.  
  659. break;
  660. }
  661.  
  662. // printDebug("finbrra");
  663. // printDebug(Integer.toString(finall_array.size()));
  664. // for (int i = 0; i < finall_array.size(); i++) {
  665. // printDebug("fingwa");
  666. // printDebug(finall_array.get(i).symbol);
  667. // printDebug(finall_array.get(i).minterm);
  668. // }
  669. }
  670.  
  671. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!