Example #1
0
  @Override
  public Optional<Suggestion> requestPlayerSuggestion(Player player, Room room) {
    char userWantsToMakeSuggestion = '\0';

    while (userWantsToMakeSuggestion != 'Y' && userWantsToMakeSuggestion != 'N') {
      this.out.println("Do you want to make an suggestion (Y/N)?");
      this.out.println("Your cards are: " + player.cards);
      userWantsToMakeSuggestion = this.scanner.next().charAt(0);
    }

    if (userWantsToMakeSuggestion == 'Y') {
      this.out.printf("You suggest it was done in the %s, by: \n", room);

      Stream<String> suspects =
          Arrays.stream(CluedoCharacter.values()).map(CluedoCharacter::toString);
      CluedoCharacter suspect = CluedoCharacter.values()[this.selectOptionFromList(suspects)];

      this.out.println("with the ");

      Stream<String> weapons = Arrays.stream(Weapon.values()).map(Weapon::toString);
      Weapon weapon = Weapon.values()[this.selectOptionFromList(weapons)];

      return Optional.of(new Suggestion(suspect, weapon, room));

    } else {
      return Optional.empty();
    }
  }
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    Integer[] startTimeInfo =
        Arrays.stream(scanner.nextLine().split(":+"))
            .map(Integer::parseInt)
            .toArray(Integer[]::new);
    Integer[] endTimeInfo =
        Arrays.stream(scanner.nextLine().split(":+"))
            .map(Integer::parseInt)
            .toArray(Integer[]::new);

    Integer minutesDifferenceFromSeconds = 0;
    Integer seconds = startTimeInfo[2] - endTimeInfo[2];
    if (seconds < 0) {
      seconds = 60 + seconds;
      minutesDifferenceFromSeconds--;
    }

    Integer hoursDifferenceFromMinutes = 0;
    Integer minutes = (startTimeInfo[1] - endTimeInfo[1]) + minutesDifferenceFromSeconds;
    if (minutes < 0) {
      minutes = 60 + minutes;
      hoursDifferenceFromMinutes--;
    }

    Integer hours = (startTimeInfo[0] - endTimeInfo[0]) + hoursDifferenceFromMinutes;

    System.out.printf("%d:%02d:%02d%n", hours, minutes, seconds);
  }
Example #3
0
  public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    String[] numbers = sc.nextLine().split(" ");

    String sort = sc.nextLine();

    if (sort.equals("Ascending")) {
      List<Integer> output =
          Arrays.stream(numbers).map(Integer::parseInt).sorted().collect(Collectors.toList());

      for (Object items : output) {
        System.out.print(items + " ");
      }
    } else if (sort.equals("Descending")) {
      List<Integer> output =
          Arrays.stream(numbers)
              .map(Integer::parseInt)
              .sorted(Comparator.reverseOrder())
              .collect(Collectors.toList());

      for (Object items : output) {
        System.out.print(items + " ");
      }
    }
  }
  public static void main(String[] args) {
    AccessIdentifiers2 ac = new AccessIdentifiers2();
    System.out.println(ac.getClass().getName());
    System.out.println(
        Arrays.stream(ac.getClass().getDeclaredFields())
            .map(Field::getName)
            .collect(Collectors.joining(" || ")));
    ;
    System.out.println(
        Arrays.stream(ac.getClass().getDeclaredMethods())
            .map(Method::getName)
            .collect(Collectors.joining(" || ")));
    System.out.println(
        Arrays.stream(ac.getClass().getDeclaredMethods())
            .map(Method::getReturnType)
            .map(Class::getName)
            .collect(Collectors.joining(" || ")));
    System.out.println(
        Arrays.stream(ac.getClass().getInterfaces())
            .map(Class::getName)
            .collect(Collectors.joining(" || ")));

    System.out.println(ac.getClass().getDeclaredFields().length);
    System.out.println(ac.getClass().getDeclaredMethods().length);
  }
  public static void main(String[] args) {
    String[] strings = {"Red", "orange", "Yellow", "green", "Blue", "indigo", "Violet"};

    // display original strings
    System.out.printf("Original strings: %s%n", Arrays.asList(strings));

    // strings in uppercase
    System.out.printf(
        "strings in uppercase: %s%n",
        Arrays.stream(strings).map(String::toUpperCase).collect(Collectors.toList()));

    // strings less than "m" (case insensitive) sorted ascending
    System.out.printf(
        "strings greater than m sorted ascending: %s%n",
        Arrays.stream(strings)
            .filter(s -> s.compareToIgnoreCase("m") < 0)
            .sorted(String.CASE_INSENSITIVE_ORDER)
            .collect(Collectors.toList()));

    // strings less than "m" (case insensitive) sorted descending
    System.out.printf(
        "strings greater than m sorted descending: %s%n",
        Arrays.stream(strings)
            .filter(s -> s.compareToIgnoreCase("m") < 0)
            .sorted(String.CASE_INSENSITIVE_ORDER.reversed())
            .collect(Collectors.toList()));
  }
 @Override
 public DefaultDataBuffer write(ByteBuffer... byteBuffers) {
   Assert.notEmpty(byteBuffers, "'byteBuffers' must not be empty");
   int extraCapacity = Arrays.stream(byteBuffers).mapToInt(ByteBuffer::remaining).sum();
   ensureExtraCapacity(extraCapacity);
   Arrays.stream(byteBuffers)
       .forEach(byteBuffer -> writeInternal(buffer -> buffer.put(byteBuffer)));
   return this;
 }
Example #7
0
 @Test
 @Ignore
 public void testKeyExtraction() {
   Employee[] emps = new Employee[] {new Employee(), new Employee(), new Employee()};
   System.out.println("Unsorted");
   Arrays.stream(emps).forEach(System.out::println);
   System.out.println("Sorted with key extractor");
   Arrays.sort(emps, Comparator.comparing(Employee::getId));
   Arrays.stream(emps).forEach(System.out::println);
 }
 static {
   ID_TO_SUPPLIER =
       unmodifiableMap(
           Arrays.stream(ElasticsearchExceptionHandle.values())
               .collect(Collectors.toMap(e -> e.id, e -> e.constructor)));
   CLASS_TO_ELASTICSEARCH_EXCEPTION_HANDLE =
       unmodifiableMap(
           Arrays.stream(ElasticsearchExceptionHandle.values())
               .collect(Collectors.toMap(e -> e.exceptionClass, e -> e)));
 }
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String inputData = scanner.nextLine();
    List<Team> championsLeague = new ArrayList<>();
    while (!inputData.equals("stop")) {
      String[] inputArgs = inputData.split("\\|+");
      String firstTeamName = inputArgs[0].trim();
      String secondTeamName = inputArgs[1].trim();

      if (!championsLeague.stream().anyMatch(t -> t.name.equals(firstTeamName))) {
        championsLeague.add(new Team(firstTeamName));
      }
      if (!championsLeague.stream().anyMatch(t -> t.name.equals(secondTeamName))) {
        championsLeague.add(new Team(secondTeamName));
      }

      Integer[] firstMatchResult =
          Arrays.stream(inputArgs[2].trim().split(":+"))
              .map(Integer::parseInt)
              .toArray(Integer[]::new);
      Integer[] secondMatchResult =
          Arrays.stream(inputArgs[3].trim().split(":+"))
              .map(Integer::parseInt)
              .toArray(Integer[]::new);

      Integer firstTeamGoals = firstMatchResult[0] + secondMatchResult[1];
      Integer secondTeamGoals = firstMatchResult[1] + secondMatchResult[0];

      Team firstTeam =
          championsLeague.stream().filter(t -> t.name.equals(firstTeamName)).findFirst().get();
      Team secondTeam =
          championsLeague.stream().filter(t -> t.name.equals(secondTeamName)).findFirst().get();

      if (firstTeamGoals > secondTeamGoals) {
        firstTeam.wins++;
      } else if (secondTeamGoals > firstTeamGoals) {
        secondTeam.wins++;
      } else if (firstTeamGoals.equals(secondTeamGoals)) {
        int firstTeamAwayGoals = secondMatchResult[1];
        int secondTeamAwayGoals = firstMatchResult[1];
        if (firstTeamAwayGoals > secondTeamAwayGoals) {
          firstTeam.wins++;
        } else {
          secondTeam.wins++;
        }
      }
      firstTeam.opponents.add(secondTeam);
      secondTeam.opponents.add(firstTeam);
      inputData = scanner.nextLine();
    }

    Collections.sort(championsLeague);
    championsLeague.forEach(System.out::println);
  }
Example #10
0
  public static float doVarianceViaStream(int[] sample) {
    Double average = Arrays.stream(sample).parallel().average().getAsDouble();
    Double variance =
        Arrays.stream(sample)
                .parallel()
                .mapToDouble(p -> ((new Double(p) - average) * (new Double(p) - average)))
                .sum()
            / sample.length;

    return variance.floatValue();
  }
  @Test
  public void testRemoveUnfinishedLeftovers_abort_multipleFolders() throws Throwable {
    ColumnFamilyStore cfs = MockSchema.newCFS(KEYSPACE);

    File origiFolder = new Directories(cfs.metadata).getDirectoryForNewSSTables();
    File dataFolder1 = new File(origiFolder, "1");
    File dataFolder2 = new File(origiFolder, "2");
    Files.createDirectories(dataFolder1.toPath());
    Files.createDirectories(dataFolder2.toPath());

    SSTableReader[] sstables = {
      sstable(dataFolder1, cfs, 0, 128),
      sstable(dataFolder1, cfs, 1, 128),
      sstable(dataFolder2, cfs, 2, 128),
      sstable(dataFolder2, cfs, 3, 128)
    };

    LogTransaction log = new LogTransaction(OperationType.COMPACTION);
    assertNotNull(log);

    LogTransaction.SSTableTidier[] tidiers = {
      log.obsoleted(sstables[0]), log.obsoleted(sstables[2])
    };

    log.trackNew(sstables[1]);
    log.trackNew(sstables[3]);

    Collection<File> logFiles = log.logFiles();
    Assert.assertEquals(2, logFiles.size());

    // fake an abort
    log.txnFile().abort();

    Arrays.stream(sstables).forEach(s -> s.selfRef().release());

    // test listing
    Assert.assertEquals(
        sstables[1].getAllFilePaths().stream().map(File::new).collect(Collectors.toSet()),
        getTemporaryFiles(dataFolder1));
    Assert.assertEquals(
        sstables[3].getAllFilePaths().stream().map(File::new).collect(Collectors.toSet()),
        getTemporaryFiles(dataFolder2));

    // normally called at startup
    LogTransaction.removeUnfinishedLeftovers(Arrays.asList(dataFolder1, dataFolder2));

    // old tables should be only table left
    assertFiles(dataFolder1.getPath(), new HashSet<>(sstables[0].getAllFilePaths()));
    assertFiles(dataFolder2.getPath(), new HashSet<>(sstables[2].getAllFilePaths()));

    // complete the transaction to avoid LEAK errors
    Arrays.stream(tidiers).forEach(LogTransaction.SSTableTidier::run);
    assertNull(log.complete(null));
  }
Example #12
0
 /**
  * A[N] N is integer in range [2..100,000] each element of A is an integer within range
  * [0..1,000,000]
  *
  * @param A non null, non-empty array
  */
 public int solution(int[] A) {
   // write your code in Java SE 8
   // if there are duplicates, the minimum will be 0
   IntStream numbers = Arrays.stream(A);
   if (numbers.distinct().count() < A.length) {
     return 0;
   } else {
     int firstMin = Arrays.stream(A).min().getAsInt();
     int secondMin = Arrays.stream(A).filter(n -> n != firstMin).min().getAsInt();
     return secondMin - firstMin;
   }
 }
Example #13
0
 public static double variance(String town, String strng) {
   if (town == null || strng == null) {
     return 0d;
   }
   double[] townTemp = getTownTemp(town, strng);
   if (townTemp.length == 0) {
     return -1d;
   }
   double average = Arrays.stream(townTemp).average().getAsDouble();
   double variance =
       Arrays.stream(townTemp).map(p -> (p - average) * (p - average)).sum() / townTemp.length;
   return variance;
 }
Example #14
0
 public boolean contentLongText(String selector, String text) {
   String shrinkText =
       Arrays.stream(text.split("\n")).map(v -> v.trim()).collect(Collectors.joining());
   Elements es = document().select(selector);
   for (Element e : es) {
     String fullText =
         Arrays.stream(e.html().trim().split("<(br|BR|Br|bR) */?>"))
             .map(v -> Arrays.stream(v.trim().split("\n")).collect(Collectors.joining()))
             .collect(Collectors.joining(""));
     if (fullText.equals(shrinkText)) return wrap(true);
   }
   addViolation(String.format("入力されたはずのテキストがDOM要素 '%s' に表示されていません", selector));
   return wrap(false);
 }
Example #15
0
 private static boolean checkCompile(String[] files) throws Exception {
   String combined = Arrays.stream(files).collect(Collectors.joining(" "));
   List<String> args =
       Arrays.stream(combined.split(" "))
           .filter(f -> f.endsWith(".java"))
           .collect(Collectors.toList());
   if (args.size() == 0) {
     return true;
   }
   args.add(0, "javac");
   ProcessBuilder pcb = new ProcessBuilder(args);
   Process p = pcb.start();
   p.waitFor();
   return p.exitValue() == 0;
 }
  // helper method to test if required files are present in the runtime
  public void testRuntime(RelativeFileSet runtime, String[] file) throws ConfigException {
    if (runtime == null) {
      return; // null runtime is ok (request to use system)
    }

    Pattern[] weave = Arrays.stream(file).map(Pattern::compile).toArray(Pattern[]::new);

    if (!runtime
        .getIncludedFiles()
        .stream()
        .anyMatch(s -> Arrays.stream(weave).anyMatch(pattern -> pattern.matcher(s).matches()))) {
      throw new ConfigException(
          MessageFormat.format(I18N.getString("error.jre-missing-file"), Arrays.toString(file)),
          I18N.getString("error.jre-missing-file.advice"));
    }
  }
Example #17
0
  public static void main(String[] args) {
    //	int[] A = { 2, 5, 7, 4, 8, 1 };
    int[] A = {14, 35, 27, 10, 35, 19, 42, 44};
    int[] sortedArr = sort(A);

    Arrays.stream(sortedArr).forEach(System.out::print);
    A = new int[] {-2, -5, 7, 4, -8, 1};
    sortedArr = sort(A);

    Arrays.stream(sortedArr).forEach(System.out::print);

    A = new int[] {2, 1, 4, 5, 7};
    sortedArr = sort(A);

    Arrays.stream(sortedArr).forEach(System.out::print);
  }
    @Override
    public void handle(ServiceRequest<GetEndpointsRequest, GetEndpointsResponse> service)
        throws UaException {
      GetEndpointsRequest request = service.getRequest();

      String endpointUrl = request.getEndpointUrl();
      if (endpointUrl == null) endpointUrl = "";

      UaTcpStackServer server = servers.get(endpointUrl);

      EndpointDescription[] endpoints =
          (server != null) ? server.getEndpointDescriptions() : new EndpointDescription[0];

      List<String> profileUris =
          request.getProfileUris() != null
              ? Lists.newArrayList(request.getProfileUris())
              : Lists.newArrayList();

      EndpointDescription[] filtered =
          Arrays.stream(endpoints)
              .filter(ed -> filterProfileUris(ed, profileUris))
              .filter(this::filterEndpointUrls)
              .toArray(EndpointDescription[]::new);

      service.setResponse(new GetEndpointsResponse(service.createResponseHeader(), filtered));
    }
 public static <T> List<T> createFromList(String raw, TypedOption<T> option) {
   if (raw == null) {
     return Collections.emptyList();
   }
   final String[] segments = raw.split(option.getListSeparator());
   return Arrays.stream(segments).map(s -> create(s.trim(), option)).collect(Collectors.toList());
 }
Example #20
0
 public BoxPlot(Frame df, GOpt... opts) {
   this.vars =
       df.varStream().filter(var -> var.stream().complete().count() > 0).toArray(Var[]::new);
   this.names = Arrays.stream(vars).map(Var::name).toArray(String[]::new);
   this.options.apply(opts);
   initialize();
 }
 /**
  * Gets the tiles that need to be deleted due to the detonating of the flame gem.
  *
  * @param tile the flame gem
  * @return tiles, the list of tiles to be deleted.
  */
 public List<Tile> getTilesToDeleteFlame(Tile tile) {
   final Point[] translations = {
     new Point(-1, 0),
     new Point(1, 1),
     new Point(0, 1),
     new Point(-1, 1),
     new Point(1, 0),
     new Point(-1, -1),
     new Point(0, -1),
     new Point(1, -1)
   };
   tile.detonate = true;
   List<Tile> tiles =
       Arrays.stream(translations)
           .map(p -> new Point(tile.getX() + p.x, tile.getY() + p.y))
           .filter(p -> board.validBorders(p.x, p.y))
           .map(p -> board.getTileAt(p.x, p.y))
           .filter(t -> !t.detonate)
           .collect(Collectors.toList());
   checkForSpecialTile(tiles);
   if (!tiles.contains(tile)) {
     tiles.add(tile);
   }
   return tiles;
 }
Example #22
0
 public String parseUri(String uri, String... uris) throws Exception {
   return parseUri(
       uri,
       uris != null
           ? Arrays.stream(uris).map(PropertiesLocation::new).collect(Collectors.toList())
           : Collections.emptyList());
 }
  @Override
  public Set<ArtifactSpec> resolveAll(final Set<ArtifactSpec> specs) {
    resetListeners();
    final MavenResolvedArtifact[] artifacts;
    try {
      artifacts =
          this.resolver
              .resolve(specs.stream().map(ArtifactSpec::mavenGav).collect(Collectors.toList()))
              .withTransitivity()
              .as(MavenResolvedArtifact.class);
    } finally {
      completeTransferListener();
    }

    return Arrays.stream(artifacts)
        .map(
            artifact -> {
              final MavenCoordinate coord = artifact.getCoordinate();
              return new ArtifactSpec(
                  "compile",
                  coord.getGroupId(),
                  coord.getArtifactId(),
                  coord.getVersion(),
                  coord.getPackaging().getId(),
                  coord.getClassifier(),
                  artifact.asFile());
            })
        .collect(Collectors.toSet());
  }
Example #24
0
  @Override
  protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters)
      throws Exception {
    List<PropertiesLocation> paths = locations;

    Boolean ignoreMissingLocationLoc =
        getAndRemoveParameter(parameters, "ignoreMissingLocation", Boolean.class);
    if (ignoreMissingLocationLoc != null) {
      ignoreMissingLocation = ignoreMissingLocationLoc;
    }

    // override default locations
    String locations = getAndRemoveParameter(parameters, "locations", String.class);
    if (locations != null) {
      LOG.trace("Overriding default locations with location: {}", locations);
      paths =
          Arrays.stream(locations.split(","))
              .map(PropertiesLocation::new)
              .collect(Collectors.toList());
    }

    String endpointUri = parseUri(remaining, paths);
    LOG.debug("Endpoint uri parsed as: {}", endpointUri);

    Endpoint delegate = getCamelContext().getEndpoint(endpointUri);
    PropertiesEndpoint answer = new PropertiesEndpoint(uri, delegate, this);

    setProperties(answer, parameters);
    return answer;
  }
Example #25
0
 /**
  * class filter of an action to use it
  *
  * @param p_method method for checking
  * @param p_root root class
  * @return boolean flag of check result
  */
 private static boolean isActionFiltered(final Method p_method, final Class<?> p_root) {
   return p_method.isAnnotationPresent(IAgentActionFilter.class)
       && ((p_method.getAnnotation(IAgentActionFilter.class).classes().length == 0)
           || (Arrays.stream(p_method.getAnnotation(IAgentActionFilter.class).classes())
               .parallel()
               .anyMatch(p_root::equals)));
 }
Example #26
0
  /**
   * reads all methods by the action-annotations for building agent-actions
   *
   * @param p_class class
   * @param p_root root class
   * @return stream of all methods with inheritance
   */
  private static Stream<Method> methods(final Class<?> p_class, final Class<?> p_root) {
    final Pair<Boolean, IAgentAction.EAccess> l_classannotation = CCommon.isActionClass(p_class);
    if (!l_classannotation.getLeft())
      return p_class.getSuperclass() == null
          ? Stream.of()
          : methods(p_class.getSuperclass(), p_root);

    final Predicate<Method> l_filter =
        IAgentAction.EAccess.WHITELIST.equals(l_classannotation.getRight())
            ? i -> !CCommon.isActionFiltered(i, p_root)
            : i -> CCommon.isActionFiltered(i, p_root);

    return Stream.concat(
        Arrays.stream(p_class.getDeclaredMethods())
            .parallel()
            .map(
                i -> {
                  i.setAccessible(true);
                  return i;
                })
            .filter(i -> !Modifier.isAbstract(i.getModifiers()))
            .filter(i -> !Modifier.isInterface(i.getModifiers()))
            .filter(i -> !Modifier.isNative(i.getModifiers()))
            .filter(i -> !Modifier.isStatic(i.getModifiers()))
            .filter(l_filter),
        methods(p_class.getSuperclass(), p_root));
  }
Example #27
0
  /**
   * returns actions by a class
   *
   * @note class must be an inheritance of the IAgent interface
   * @param p_class class list
   * @return action stream
   */
  @SuppressWarnings("unchecked")
  public static Stream<IAction> actionsFromAgentClass(final Class<?>... p_class) {
    return p_class == null || p_class.length == 0
        ? Stream.of()
        : Arrays.stream(p_class)
            .parallel()
            .filter(IAgent.class::isAssignableFrom)
            .flatMap(i -> CCommon.methods(i, i))
            .map(
                i -> {
                  try {
                    return (IAction) new CMethodAction(i);
                  } catch (final IllegalAccessException l_exception) {
                    LOGGER.warning(
                        CCommon.languagestring(CCommon.class, "actioninstantiate", i, l_exception));
                    return null;
                  }
                })

            // action can be instantiate
            .filter(Objects::nonNull)

            // check usable action name
            .filter(CCommon::actionusable);
  }
Example #28
0
  private void runExperiment(String experimentCode) {
    Class experimentClass =
        Arrays.stream(experimentsAvailable)
            .filter(
                (Class<? extends BaseExperiment> filteredexperimentClass) -> {
                  try {
                    return filteredexperimentClass
                            .getConstructor()
                            .newInstance()
                            .getCodeName()
                            .compareTo(experimentCode)
                        == 0;
                  } catch (Exception ex) {
                    Logger.getLogger(Runner.class.getName()).log(Level.SEVERE, null, ex);
                  }
                  return false;
                })
            .findFirst()
            .orElse(null);

    if (experimentClass != null) {
      try {
        BaseExperiment experiment = (BaseExperiment) experimentClass.getConstructor().newInstance();
        experiment.run(arguments);
      } catch (Exception ex) {
        Logger.getLogger(Runner.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
  }
 public static String threadName(Settings settings, String... names) {
   String namePrefix =
       Arrays.stream(names)
           .filter(name -> name != null)
           .collect(Collectors.joining(".", "[", "]"));
   return threadName(settings, namePrefix);
 }
 @NotNull
 private static PsiElement[] extractReferencedVariables(@NotNull PsiTypeElement typeElement) {
   final PsiElement parent = typeElement.getParent();
   if (parent instanceof PsiVariable) {
     if (parent instanceof PsiField) {
       PsiField aField = (PsiField) parent;
       List<PsiField> fields = new ArrayList<>();
       while (true) {
         fields.add(aField);
         aField = PsiTreeUtil.getNextSiblingOfType(aField, PsiField.class);
         if (aField == null || aField.getTypeElement() != typeElement) {
           return fields.toArray(new PsiElement[fields.size()]);
         }
       }
     } else if (parent instanceof PsiLocalVariable) {
       final PsiDeclarationStatement declaration =
           PsiTreeUtil.getParentOfType(parent, PsiDeclarationStatement.class);
       if (declaration != null) {
         return Arrays.stream(declaration.getDeclaredElements())
             .filter(PsiVariable.class::isInstance)
             .toArray(PsiVariable[]::new);
       }
     }
     return new PsiElement[] {parent};
   } else {
     return PsiElement.EMPTY_ARRAY;
   }
 }