Votre tâche consiste à écrire un programme informatique de telle sorte que lorsqu'il est découpé en lignes (divisé sur le caractère de nouvelle ligne) chaque arrangement des lignes produira un nombre différent entre 1 et n! (où n est le nombre total de lignes). Aucun nombre ne doit être sorti par deux arrangements différents et chaque arrangement devrait sortir un nombre sur cette plage. Puisqu'il n'y en a pas ! façons d'organiser les lignes d'un programme, cela signifie que chaque numéro doit être sorti par un réarrangement.

Par exemple le programme python

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

A deux dispositions

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

et

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

Les premières sorties 1et les secondes sorties 2.

Vous pouvez utiliser tous les formats de sortie standard dans la langue que vous utilisez. Vous ne pouvez assumer aucune sorte de passe-partout. Je pense que ce défi est plus intéressant si vous devez contourner les formats sur lesquels la langue insiste.

Notation

Votre score sera le nombre de lignes de votre programme, un score plus élevé étant meilleur. Vous pouvez choisir de sortir des nombres de 0 à n! -1 si vous le souhaitez.

CJam , score: ∞

Chaque ligne est de la forme

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

où xest un nombre de 0à n-1. Le résultat est dans la plage 0de n!-1.

Essayez-le en ligne! (Pour n=3.)

Crédits à jimmy23013 pour le code qui calcule l'indice de permutation réel. J'ai seulement remplacé le bit qui lit l'entrée avec ];Lx+:Llaquelle rejette le résultat de la ligne précédente et ajoute ensuite l'index de la ligne actuelle à la variable L(qui est initialement un tableau vide).

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/}

Prolongez à n'importe quelle longueur que vous aimez

Manquera rapidement de mémoire car l'utilisation de la mémoire est comme O (n ^ n). Il serait cependant facile de remplacer l'indexeur de permutation par du code O (n), juste plus longtemps. J'illustre simplement la façon dont vous pouvez utiliser END{}pour cette tâche en perl. Tous les END{}blocs s'exécutent au moment de la sortie, mais seul le premier qui est appelé (le dernier dans le code) affichera quoi que ce soit en raison du /A/test qui n'est vrai qu'une fois

Notez que le $mcompteur doit compter comme une chaîne car comme un nombre, il déborderait (plus tard que la fin de l'univers mais c'est le principe qui compte). Pour la même raison, je "compte" le nombre de lignes en construisant une chaîne de As au lieu d'utiliser un vrai compteur bien que ce débordement se produise encore plus tard.

Une autre façon de le faire en 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),

Cela utilise ce fait que in foo = bar barest exécuté après foo. Cette version, en passant, ne devient pas folle dans le temps et l'espace, mais cela allonge le code

Encore une autre idée est d'utiliser DESTROYce qui a l'avantage de ne faire exécuter qu'une seule d'entre elles. Je ne vais pas répéter le code d'indexation de permutation dont j'ai déjà donné deux exemples.

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 en utilisant 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;

Gelée , ∞

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

(Exemple avec n=3.)

Essayez-le en ligne!

23 13 11 octets par ligne.

Pour un programme avec des nlignes, les lignes auront le format

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

où <i>représente le nombre littéral iet chaque ligne a une valeur différente pour ialler de 1à n. (Les valeurs de ine doivent pas nécessairement être ces nombres spécifiques, elles doivent simplement avoir des valeurs positives uniques.) Ce programme n'utilise plus ndans la structure de ligne.

Comment?

• Sans argument, Jelly commence par 0.
• ;1s'ajoute 1à 0ou à la liste active.
• ⁼Q$est la monade conditionnelle de l'instruction if ( ?) qui vérifie si les éléments de la liste sont uniques. S'ils le sont, le lien ci-dessus est appelé ( Ç) et un autre numéro est ajouté à la liste. S'ils ne sont pas uniques, cela signifie que nous sommes passés au premier lien. L'élément répété est supprimé de la liste ( Q) et l'index de la permutation est trouvé ( Œ¿). Notez qu'il y a un 0au début de la liste quand Œ¿est pris mais cela n'affecte pas la sortie car les valeurs de isont toutes positives.

Nouvelle fonctionnalité Jelly

Avec le nouvel ajout Ƒrapide, nous pouvons réduire ⁼Q$à QƑ, économisant un octet.

10 octets / ligne (pour les chiffres uniques)

;1ÇQŒ¿$QƑ?

Essayez-le en ligne!

Brain-Flak , 3

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

Essayez-le en ligne!

J'ai posté cela dans le chat plus tôt, mais j'espère qu'en le publiant ici, les gens pourront en tirer parti.

Explication

Nous commençons par le programme de base

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

Cela vaut 2 à lui seul. Afin de passer au niveau suivant, je veux ajouter une nouvelle ligne. Ma conjecture de départ était

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

Cela définit le TOS 2s'il est nul et ne fait rien d'autre. C'est en fait un bon début. Avec les deux autres lignes, nous pouvons obtenir tous les nombres de 1à 6excepté 4, car il existe des 2moyens de produire 2:

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

et

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

Afin de remédier à cela, nous faisons également en sorte que notre gamme 2soit 4. Cela peut être fait avec

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

Pour plus de clarté, cela implémente essentiellement la fonction Haskell

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

Cela résout notre problème car l'un des programmes qui était précédemment en sortie génère 2désormais 4aucun autre programme.

Java 7, score: ∞

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));}}

Essayez-le en ligne!

C'est peut imprimer 0 à n! -1 . Les lignes supplémentaires ont le format suivant (où INDEX est un nombre compris entre 1 et n! -1 ):

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

Cette méthode fonctionne en lisant sa propre source afin de déterminer les classes d'ordre qui y sont répertoriées. Malheureusement, il n'y avait pas de méthode plus cool que je pouvais trouver en analysant le fichier compilé ou en créant un ClassLoader personnalisé grâce à la façon dont java compile JIT. Je suppose que je pourrais avoir chaque classe supplémentaire juste imprimer un nombre défini statiquement, mais cela semblait plus amusant. Cela permettrait également de supprimer l' Binterface, mais le score n'est pas basé sur des octets, je vais donc laisser cela pour le plaisir.

Comment ça marche (haut niveau):

Lit son propre code source ligne par ligne. Puisque chaque ligne déclare une nouvelle classe, nous utilisons la réflexion pour créer une instance de la nouvelle classe et invoquer sa améthode dont elle a besoin car elle implémente l' Binterface.

Ruby , score: ∞

(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))

Essayez-le en ligne!

Ce programme a 61 octets par ligne (pour n <10). Il a le même format de base que la solution de dylnan ; le premier nombre de chaque ligne sera une valeur différente entre 1et n, et le deuxième nombre de chaque ligne sera n.

J'espérais trouver un moyen d'éviter d'inclure ndans le programme, mais je n'ai pas pu en trouver un.

Brain-Flak , 2 (avec -d)

{}(@ltN)

Essayez-le en ligne!

05AB1E , score: 1114112

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

Essayez-le en ligne! 0 indexé. Le ˆ au début de chaque ligne pousse les caractères distincts dans le tableau global. Le reste du code est inutilement exécuté sauf sur la dernière ligne, où il concatène les valeurs dans une chaîne, puis trouve son indice de permutation. 1.114.112 est le nombre de caractères Unicode possibles au moment de la rédaction (les points de code 48-57 sont les plus faciles à démontrer avec bien sûr).