Sua tarefa é escrever um programa de computador, de modo que, quando ele for cortado em linhas (dividido no caractere de nova linha), todo arranjo das linhas produza um número diferente entre 1 e n! (onde n é o número total de linhas). Nenhum número deve ser emitido por dois arranjos diferentes e todo arranjo deve gerar um número nesse intervalo. Uma vez que existem n! maneiras de organizar as linhas de um programa, isso significa que cada número deve ser gerado por um rearranjo.

Por exemplo, o programa python

print 1;"""
print 2;"""

Tem dois arranjos

print 1;"""
print 2;"""

e

print 2;"""
print 1;"""

As primeiras saídas 1e as segundas saídas 2.

Você pode usar os formatos de saída padrão no idioma que está usando. Você não pode assumir nenhum tipo de clichê. Eu acho que esse desafio é mais interessante se você precisar contornar os formatos que o idioma insistir.

Pontuação

Sua pontuação será o número de linhas no seu programa, com uma pontuação maior sendo melhor. Você pode escolher números de 0 a n! -1, se desejar.

CJam , pontuação: ∞

Cada linha é da forma

];Lx+:L{__(f<0+:+\,,(;1+:**\(;}h]:+

onde xé um número de 0para n-1. O resultado está no intervalo 0de n!-1.

Experimente online! (Para n=3.)

Créditos para jimmy23013 para o código que calcula o índice de permutação real. Substituí apenas o bit que lê a entrada com a ];Lx+:Lqual descarta o resultado da linha anterior e adiciona o índice da linha atual à variável L(que é inicialmente uma matriz vazia).

Perl: ∞

$z.="-1,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-2,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-3,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}

Estenda o comprimento que desejar

A memória ficará rapidamente rapidamente, pois o uso da memória é como O (n ^ n). No entanto, seria fácil substituir o indexador de permutação pelo código O (n), apenas por mais tempo. Estou apenas ilustrando a maneira como você pode usar END{}esta tarefa em perl. Todos os END{}blocos são executados no momento da saída, mas apenas o primeiro chamado (o último no código) produzirá algo devido ao /A/teste, que só é verdadeiro uma vez

Observe que o $mcontador deve contar como uma cadeia, porque, como número, transbordaria (mais tarde que o fim do universo, mas é o princípio que conta). Pela mesma razão, eu "conto" o número de linhas construindo uma sequência de As em vez de usar um contador real, embora esse estouro ocorra ainda mais tarde.

Outra maneira de fazer isso em perl:

@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"1".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"2".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"3".!($a.=A),

Isso usa o fato de que in foo = bar baré executado depois foo. Esta versão, a propósito, não fica louca no tempo e no espaço, mas isso torna o código mais longo

Ainda outra idéia é usar, DESTROYque tem a vantagem de que apenas um deles será executado. Não vou repetir o código de indexação de permutação do qual já dei dois exemplos.

push@F,"1";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"2";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"3";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }

Ou usando BEGIN:

BEGIN{push@F,"1"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"2"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"3"} print"Work out permutation index of @F\n"; exit;

Jelly , ∞

;3ÇQŒ¿$⁼Q$?
;2ÇQŒ¿$⁼Q$?
;1ÇQŒ¿$⁼Q$?

(Exemplo com n=3.)

Experimente online!

23 13 11 bytes por linha.

Para um programa com nlinhas, as linhas terão o formato

; <i> ÇQŒ¿$⁼Q$?

onde <i>representa o número literal ie cada linha tem um valor diferente para ivariar de 1até n. (Na iverdade, os valores para não precisam ser esses números específicos, apenas precisam ter valores positivos únicos.) Este programa não é mais usado nna estrutura de linhas.

Quão?

• Sem uma discussão, Jelly começa 0.
• ;1anexa 1à 0ou à lista ativa.
• ⁼Q$é a mônada condicional da instrução if ( ?) que verifica se os elementos da lista são exclusivos. Se estiverem, o link acima é chamado ( Ç) e outro número é anexado à lista. Se não forem únicos, significa que aderimos ao primeiro link. O elemento repetido é removido da lista ( Q) e o índice da permutação é encontrado ( Œ¿). Observe que existe um 0no início da lista quando Œ¿é obtido, mas isso não afeta a saída, pois os valores para isão todos positivos.

Novo recurso Jelly

Com o recém-adicionado Ƒquick, podemos reduzir ⁼Q$para QƑ, economizando um byte.

10 bytes / linha (para um dígito)

;1ÇQŒ¿$QƑ?

Experimente online!

Flacidez Cerebral , 3

(({}){})
({}())
(()(){([()()]{})()(){[()()](<{}>)}}{})

Experimente online!

Eu postei isso no chat mais cedo, mas espero que ao postá-lo aqui, as pessoas possam aproveitar disso.

Explicação

Começamos com o programa básico

(({}){})
({}())

Isso marca 2 por si só. Para avançar para o próximo nível, quero adicionar uma nova linha. Meu palpite inicial era

(()(){[()()]{}(<()>)}{})

Isso define o TOS como 2se for zero e não fizer nada de outra maneira. Este é realmente um bom começo. Com as outras duas linhas que são capazes de obter todos os números de 1que 6, exceto 4, porque há 2maneiras de saída 2:

({}())
(({}){})
(()(){[()()]{}(<()>)}{})

e

({}())
(()(){[()()]{}(<()>)}{})
(({}){})

A fim de remediar esta situação fazemos nossa linha também definir 2-se 4. Isso pode ser feito com

(()(){([()()]{})()(){[()()](<{}>)}}{})

Para maior clareza, isso basicamente implementa a função Haskell

f 0 = 2
f 2 = 4
f x = x

Isso corrige o nosso problema, porque um dos programas que estava sendo lançado anteriormente 2agora sai 4sem nenhuma outra alteração de programa.

Java 7, pontuação: ∞

public class DerangedRearrangements implements B{public void a(){System.out.println("0");}public static void main(String[]a)throws Exception{java.util.regex.Pattern p=java.util.regex.Pattern.compile("^(?:public )?class ([\\w]+).*");java.io.BufferedReader r=new java.io.BufferedReader(new java.io.FileReader("./DerangedRearrangements.java"));String line; while((line=r.readLine())!=null){java.util.regex.Matcher m=p.matcher(line);if(m.matches()){((B)Class.forName(m.group(1)).getDeclaredConstructor().newInstance()).a();}}}}interface B{void a();}
class b1 implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

Experimente online!

Isso pode imprimir 0 a n! -1 . Linhas adicionais têm o seguinte formato (onde INDEX é um número de 1 a n! -1 ):

class b<INDEX> implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

Esse método funciona lendo sua própria fonte para determinar as classes de ordem listadas nele. Infelizmente, não havia um método mais legal que eu pudesse encontrar analisando o arquivo compilado ou criando um ClassLoader personalizado, graças a como o java faz a compilação JIT. Suponho que cada classe adicional imprima apenas um número definido estaticamente, mas isso parece mais divertido. Isso também faria com que eu pudesse remover a Binterface, mas a pontuação não é baseada em bytes, então deixarei isso por diversão.

Como funciona (alto nível):

Lê seu próprio código fonte linha por linha. Como cada linha declara uma nova classe, usamos a reflexão para criar uma instância da nova classe e invocar seu amétodo que ele precisa, porque implementa a Binterface.

Ruby , pontuação: ∞

(a||=[])<<2;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<1;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<3;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))

Experimente online!

Este programa possui 61 bytes por linha (para n <10). Tem o mesmo formato básico que a solução de dylnan ; o primeiro número em cada linha terá um valor diferente entre 1e n, e o segundo número em cada linha será n.

Eu esperava encontrar uma maneira de evitar a inclusão nno programa, mas não consegui encontrar uma.

Brain-Flak , 2 (com -d)

{}(@ltN)

Experimente online!

05AB1E , pontuação: 1.114.112

0ˆ¯JD{œsk
1ˆ¯JD{œsk
2ˆ¯JD{œsk

Experimente online! Indexado a 0. O ˆ no início de cada linha envia os caracteres distintos para a matriz global. O restante do código é inutilmente executado, exceto na última linha, onde concatena os valores em uma string e, em seguida, encontra seu índice de permutação. 1.114.112 é o número possível de caracteres Unicode no momento da escrita (os pontos de código 48 a 57 são os mais fáceis de demonstrar, é claro).