Dado um número inteiro positivo n, projete um transferidor com o menor número de marcas que permita medir todos os ângulos que são um múltiplo integral de 2π/n(cada um em uma única medição).

Detalhes

Como saída, você pode enviar uma lista de números inteiros no intervalo 0para n-1(ou 1para n) que representam a posição de cada marca. Como alternativa, você pode gerar uma string / lista de comprimento ncom a #na posição de cada marca e a _(sublinhado) onde não há nenhuma. (Ou dois caracteres diferentes, se for mais conveniente.)
Exemplo: Para que n = 5você precise exatamente de 3 marcas para poder medir todos os ângulos 2π/5, 4π/5, 6π/5, 8π/5, 2π, defina (por exemplo) uma marca em 0, uma marca em 2π/5e uma marca em 6π/5. Podemos codificar isso como uma lista [0,1,3]ou como uma string ##_#_.

Exemplos

Observe que as saídas não são necessariamente únicas.

n:  output:
 1  [0]
 2  [0,1]
 3  [0,1]
 4  [0,1,2]
 5  [0,1,2]
 6  [0,1,3]
 7  [0,1,3]
 8  [0,1,2,4]
 9  [0,1,3,4]
10  [0,1,3,6]
11  [0,1,3,8]
20  [0,1,2,3,6,10]

PS: É semelhante ao problema da régua esparsa , mas em vez de uma escala linear (com duas extremidades), consideramos uma escala circular (angular).

PPS: esse script deve calcular um exemplo de um conjunto de marcas para cada um n. Experimente online!

PPPS: Como o @ngn apontou, esse problema é equivalente a encontrar uma base de diferença mínima de um grupo cíclico de ordem n. Os pedidos mínimos estão listados em http://oeis.org/A283297 e alguns limites teóricos são encontrados em https://arxiv.org/pdf/1702.02631.pdf

Gelatina , 13 bytes

ŒPðṗ2I%QLðÐṀḢ

Experimente online!

Como funciona

ŒPðṗ2I%QLðÐṀḢ  Main link. Argument: n (integer)

ŒP             Powerset; generate all subsequences of [1, ..., n].
  ð       ÐṀ   Begin a dyadic chain. Call it with all subsequences S as left
               argument and n as right one. Return the array of all sequences for
               which the chain returns the maximal result, i.e., [0, ..., n-1].
   ṗ2              Cartesian power 2; generate all pairs of elements of S.
     I             Increments; map each pair [x, y] to [y-x].
      %            Map each [y-x] to [(y-x)%n].
       Q           Unique; deduplicate the array of modular difference singletons.
        L          Take the length.
         ð     Begin a new, dyadic chain.
               Left argument: S' (filted subsequences). Right argument: n
            Ḣ  Take the first element of S'.
               Since S was sorted by length, so is S', so the first element of S'
               is the shortest subsequence that satisfies the condition.

MATL , 20 bytes

:qGZ^!"G:q@&-G\m?@u.

Isso fica sem memória no TIO para entradas além 8.

Experimente online!

Como funciona

Isso gera o poder cartesiano de [0 1 ... n-1]com expoente ne usa um loop para testar cada tupla cartesiana. O teste consiste no cálculo todas as diferenças de pares de elemento se a tupla, e ver se essas diferenças modulo nincluem todos os números 0, 1, ..., n-1.

Assim que uma tupla cartesiana que preenche a condição é encontrada, o loop é encerrado e as entradas exclusivas nessa tupla são impressas como a solução.

Isso funciona porque, dado u > v , é garantido que um conjunto suficiente de tuplas com u entradas exclusivas seja testado antes de qualquer tupla com v entradas exclusivas. Um "conjunto suficiente" significa que se nenhuma das tuplas nesse conjunto for uma solução, nenhuma outra tupla com o mesmo número de entradas exclusivas será uma solução.

Por exemplo, para n = 3as tuplas cartesianas são mostradas abaixo, onde cada linha é uma tupla:

0 0 0
0 0 1
0 0 2
0 1 0
0 1 1
0 1 2
0 2 0
 ···
2 2 1
2 2 2

• A primeira tupla,, 0 0 0é a única tupla relevante com 1valor único. Mesmo que 1 1 1e 2 2 2apareça muito mais tarde, 0 0 0é uma solução se e somente se forem. Portanto, o conjunto de singleton formado pela tupla 0 0 0é um conjunto suficiente para u = 1.
• A segunda e terceira tuplas, a saber , 0 0 1e 0 0 2, formam um conjunto suficiente para u = 2; isto é, eles cobrem todos os casos com 2valores únicos. A quarta tupla,, 0 1 0nunca será selecionada como solução, porque 0 0 1será testada primeiro. Da mesma forma, a tupla 0 2 0nunca será selecionada porque aparece depois 0 0 2. Tuplas como 2 2 1nunca serão selecionadas como solução porque 0 0 1são equivalentes (módulo ne até valores duplicados) e aparecem primeiro.
• Etc.

Código comentado:

:q         % Push [0 1 ... n-1], where n is the input (implicit)
GZ^        % Cartesian power with exponent n. Gives an (n^n) × n matrix
           % where each row is a Cartesian tuple
!          % Transpose. Now each Cartesian tuple is a column
!"         % For each column (that is, each Cartesian tuple)
  G:q      %   Push [0 1 ... n-1] (*)
  @        %   Push current column
  &-       %   Matrix of pairwise differences (**)
  G\       %   Modulo n, element-wise
  m        %   Ismember function: for each entry in (*), gives true iff
           %   it is present in (**)
  ?        %   If all entries are true
    @      %     Push current column
    u      %     Unique entries. This is the solution
    .      %     Break loop
           %   End (implicit)
           % End (implicit)
           % Display (implicit)

Stax , 26 21 bytes

Åæ4&╕u◙╩►s∙Φ▬═(0~ d+Q

Execute e depure online!

No momento, a versão online falha na entrada, 20mas esse bug foi corrigido e ainda deve ser implantado no intérprete online Implementado. Cuidado, leva algum tempo para executar o 20caso.

Explicação

Acontece que, devido à maneira como a diferença por pares é calculada, não preciso me preocupar com a equivalência de ke x-kaqui. Salvando 5 bytes.

Usa a versão descompactada para explicar.

rS{%o~{;i@c:2{E-x%mu%x<wm
r                            [0..`x`], where `x` is input
 S                           Powerset
  {%o~                       Sort by length
      {;i@             w     For each element in the powerset
          c:2                All pairs
             {    m          Map each pair `[p,q] to
              E-                 `q-p`
                x%               `(q-p)%x`
                   u%        Count of unique modulo differences
                     x<      Loop until the count of unique modulo differences is larger than the input(`n`)
                             Now we have found a valid set in the powerset
                        m    Output the members of the set,one element per line.

Fazendo cumprir a exigência de que 0e 1tanto ser membros da resposta, podemos gerar o powerset com [2..x]em vez de [0..x]e, em seguida, adicionar o 0e 1manualmente para cada elemento da Powerset. É mais eficiente, mas precisa lidar com a entrada 1especialmente e custa mais bytes.

Gelatina , 17 bytes

_þ¹F%³³Ḷ¤ḟ
ŒPÇÐḟḢ

Experimente online!

-1 byte graças ao Sr. Xcoder

Python 2 , 148 bytes

from itertools import*
def f(n):
 r=range(n)
 for i in r:
  for p in combinations(r,i+1):
   if all(any((y+x)%n in p for y in p)for x in r):return p

Experimente online!