import java.io.IOException;
import java.nio.file.*;
import java.util.*;
import java.util.function.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class WordCount {
  public static void main(String[] args) throws IOException {
    if (args.length != 1) {
      System.err.println("File name required");
      return;
    }
    Path path = Paths.get(args[0]);
    Map<String, Long> counts = Files.lines(path)
        .flatMap(Pattern.compile("\\W+")::splitAsStream)
        .map(String::trim)
        .filter(Predicate.not(String::isEmpty))
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    counts.entrySet().stream()
         .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
         .limit(20)
         .map(e -> e.getKey() + "\t" + e.getValue())
         .forEach(System.out::println);
  }
}

package com.jetbrains.completion.ranker.model.java;
/*
* WARNING: This file is a generated one, please do not edit it.
*/
public class Tree0 {
public static double calcTree(double[] fs) {
if (fs[54] <= 0.5) {
if (fs[59] <= 0.9736842215061188) {
if (fs[88] <= 0.5) {
if (fs[68] <= 25.0) {
if (fs[30] <= 0.41428571939468384) {
if (fs[38] <= 0.0005793680320493877) {
if (fs[84] <= 9953.5) {
if (fs[55] <= -903.5) {
if (fs[36] <= 0.00043574847222771496) {
if (fs[15] <= 0.5) {
if (fs[49] <= 0.5) {
if (fs[31] <= 0.31414473056793213) {
return 0.3141634980988593;
} else {
return 0.538899430740038;
}
} else {

public class Person {
    String firstName, lastName;
    int age;
}

import java.util.Objects;
public class Person {
    String firstName, lastName;
    int age;
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
         if (this == o) {
            return true;
       }
       if (o == null || getClass() != o.getClass()) {
          return false;
       }
       Person person = (Person) o;
       return age == person.age &&
              Objects.equals(firstName, person.firstName) &&
              Objects.equals(lastName, person.lastName);
    }
    @Override
    public int hashCode() {
        return Objects.hash(firstName, lastName, age);
    }
    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", age=" + age +
                '}';
    }
}

import lombok.*;
@Data
@AllArgsConstructor
public class Person {
    String firstName, lastName;
    int age;
}

data class Person(
  var firstName: String,
  var lastName: String,
  var age: Int)

boolean checkValid(Data data) {
    if (hasError(data.getContent())) return false;
    return !hasError(data.getInheritedContent());
}
boolean hasError(List<String> content) {
    for (String str : content) {
        if (isInvalidString(str)) return true;
    }
    return false;
}

boolean checkValid(Data data) {
    for (String str1 : data.getContent()) {
        if (isInvalidString(str1)) return false;
    }
    for (String str : data.getInheritedContent()) {
        if (isInvalidString(str)) return false;
    }
    return true;
}

if __name__ == '__main__':
    divisors = [(3, 'fizz'), (5, 'buzz')]
    for i in range(1, 101):
        output = ''
        for d in divisors:
            if query_search_engine(i, d[0]):
                output += d[1]
        output = output or i
        print(output)

base_url = 'https://www.answers.com/Q/'
def query_search_engine(numerator, denominator):
    ''' ask a search engine if these numbers are divisible '''
    question = 'is %d divisible by %d' % (numerator, denominator)
    question = question.replace(' ', delimiter)
    url = '%s%s' % (base_url, question)
    request = Request(url)
    request.add_header(
        'User-Agent',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:72.0) ' \
        'Gecko/20100101 Firefox/72.0')
    response = urlopen(request)
    # politeness -- wait a few seconds before the next query
    time.sleep(3)
    if url != response.url:
        return False
    text = response.read().decode('unicode-escape')
    parser = SearchParser()
    parser.feed(text)
    return parser.conclude_yes_no()

# words that indicate whether the answer is yes or no
self.positive_signs = ['yes', 'exactly', 'is divisible']
self.negative_signs = ['no', 'not', 'decimal']
…
def score_answer(self, answer):
    ''' evaluates an answer to determine if it's a yes or a no '''
    score = 0
    positive_signs = re.findall(
        r'\b%s\b' % r'\b|\b'.join(self.positive_signs),
        answer,
    )
    score += len(positive_signs)
    negative_signs = re.findall(
        r'\b%s\b' % r'\b|\b'.join(self.negative_signs),
        answer
    )
    score -= len(negative_signs)
    return score

myfunc(s)
char *s
{
  void a();
  int i, j;
  a("hello");
}

% lint myfile.c
myfile.c:
myfile.c(2): warning: argument s unused in function myfunc
myfile.c(6): warning: i unused in function myfunc
myfile.c(6): warning: j unused in function myfunc
%

fprintf(stderr, "%s: -f argument %s invalid\n",
        progname, optarg);
lint:
function returns value which is always ignored
    fprintf

(void) fprintf(stderr, "%s: -f argument %s invalid\n",
               progname, optarg);

void processData(Data data) {
    if (data != null) {
       setHasData(true);
       validate(data);
       for (Item item : data.getItems()) {
           processItem(item);
       }
       afterProcessing();
    }
}

void processData(Data data) {
    if (data != null) {
       setHasData(true);
       validate(data);
       for (Item item : data.getItems()) {
           processItem(item);
       }
    }
    afterProcessing();
}

void processData(Data data) {
    if (data != null) {
        setHasData(true);
    }
    validate(data);
    assert data != null;
    for (Item item : data.getItems()) {
        processItem(item);
    }
    afterProcessing();
}

void processData(Data data) {
    if (!data.isEmpty()) {
        setHasData(true);
    }
    validate(data);
    for (Item item : data.getItems()) {
        processItem(item);
    }
    afterProcessing();
}

<artifactId>junit</artifactId>
-<version>4.13</version>
+<version>4.13.1</version>
<scope>test</scope>

public class Foo {
  public static boolean check(String s) {
    return s.matches("foo|bar");
  }
}

import static org.junit.Assert.assertFalse;
import org.junit.Test;
public class FooTest {
  @Test
  public void testCheck() {
    assertFalse(Foo.check("s"));
  }
}

public class Foo {
  public static boolean check(String s) {
    if (s.matches("foo|bar")) {
      return true;
    } else {
      return false;
    }
  }
}

public class FooTest {
  @Test
  public void testCheck() {
    assertFalse(Foo.check("s"));
    assertTrue(Foo.check("foo"));
  }
}

public class Foo {
  public static boolean check(String s) {
    if (s.matches("\\da[X-Z]{2}\\d")) {
      return true;
    } else {
      return false;
    }
  }
}

public class FooTest {
  @Test
  public void testCheck() {
    assertFalse(Foo.check("s"));
    assertTrue(Foo.check("9aYY9"));
  }
}

public static String fizzBuzz(int x) {
  if (x % 15 == 0) {
    return "FizzBuzz";
  }
  if (x % 5 == 0) {
    return "Fizz";
  }
  if (x % 3 == 0) {
    return "Buzz";
  }
  return String.valueOf(x);
}

@Test
public void testFizzBuzz() {
  assertEquals("2", fizzBuzz(2));
  assertEquals("FizzBuzz", fizzBuzz(0));
  assertEquals("Fizz", fizzBuzz(5));
  assertEquals("Buzz", fizzBuzz(3));
}

public class Person {
  final String name;
  final int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  boolean isValid() {
    return !name.isEmpty() && age >= 0;
  }
}

public class PersonTest {
  @Test
  public void testIsValid() {
    assertTrue((new Person("name", 1)).isValid());
    assertFalse((new Person("", 1)).isValid());
    assertFalse((new Person("name", -1)).isValid());
  }
}