board[pos+2*dir] = '○'
}

// solve tries to find a sequence of moves such that there is only one peg left
// at the end; if center is >= 0, that last peg must be in the center position.
// If a solution is found, solve prints the board after each move in a backward
// fashion (i.e., the last board position is printed first, all the way back to
// the starting board position).
func solve() bool {
	var last, n int

    /**
     * Returns the list of components which are in conflict on this capability
     */
    List<ComponentVariantIdentifier> getCandidates();

    /**
     * Selects a particular candidate to solve the conflict. It is recommended to
     * provide a human-readable explanation to the choice by calling the {@link #because(String)} method
     *
     * @param candidate the selected candidate
     * @return this details instance

* In many cases, it's better to understand their **underlying problem or use case**, because there might be a better way to solve it than what they are trying to do.

### Ask to close

If they reply, there's a high chance you would have solved their problem, congrats, **you're a hero**! 🦸

* Now, if that solved their problem, you can ask them to:

    * In GitHub Discussions: mark the comment as the **answer**.

---
name: Feature request
about: Suggest an idea
title: ''
labels: enhancement
assignees: ''

---

Start by telling us what problem you’re trying to solve. Often a solution already exists!

// run

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Solve the 2,3,5 problem (print all numbers with 2, 3, or 5 as factor) using channels.
// Test the solution, silently.

package main

type T chan uint64

func M(f uint64) (in, out T) {
	in = make(T, 100)
	out = make(T, 100)
	go func(in, out T, f uint64) {
		for {

[[sub:selecting-preferred-capability-provider]]
=== Selecting between different capability candidates

In the relocation example above, Gradle was able to tell you that you have two versions of the same API on classpath: an "old" module and a "relocated" one.

    conflict with the copy of ListenableFuture in guava itself. If users are
    using an older version of Guava or a build system other than Gradle, they
    may see class conflicts. If so, they can solve them by manually excluding
    the listenablefuture artifact or manually forcing their build systems to
    use 9999.0-....
  </description>
  <build>
    <plugins>
      <plugin>

        this.stringNotation = stringNotation;
    }

    @Override
    public boolean isSatisfiedBy(DependencyResult candidate) {
        //The matching is very simple at the moment but it should solve majority of cases.
        //It operates using String#contains and it tests either requested or selected module.
        if (candidate instanceof ResolvedDependencyResult) {

    public String asClickableFileUrl(File path) {
        // File.toURI().toString() leads to a URL like this on Mac: file:/reports/index.html
        // This URL is not recognized by the Mac console (too few leading slashes). We solve
        // this be creating an URI with an empty authority.
        try {
            return new URI("file", "", path.toURI().getPath(), null, null).toASCIIString();
        } catch (URISyntaxException e) {

    // IDE tries to acquire its bytecode via the index, however,
    // the index doesn't cover classfiles from compiler output,
    // so the lowering fails.
    //
    // To solve the problem, we need to find all delegated properties with inline accessors
    // reachable from files that will be compiled, and include files these inline accessors