Successeurs de gamme inversée

21

Étant donné un entier positif n, procédez comme suit (et sortez à chaque étape):

  1. commencer par une liste contenant des ncopies de n.
  2. procédez comme suit n:
  3. à la ie étape, décrémenter progressivement la ie entrée de la liste jusqu'à ce qu'elle atteignei

Ainsi, par exemple, si le GIVEN nest 4, vous commencez avec [4,4,4,4], puis lors de la première étape que vous avez [3,4,4,4], [2,4,4,4], [1,4,4,4]. Lors de la deuxième étape, vous avez [1,3,4,4], [1,2,4,4]. À la troisième étape, vous avez [1,2,3,4]. Rien n'est fait sur la quatrième étape.

Votre sortie est donc [[4,4,4,4],[3,4,4,4],[2,4,4,4],[1,4,4,4],[1,3,4,4],[1,2,4,4],[1,2,3,4]].

Tout format d'entrée / sortie raisonnable est autorisé.

Des échappatoires standard s'appliquent. C'est le code-golf : la réponse avec le plus petit nombre d'octets gagne.

Implémentation de Python à des fins de vérification .

code-golf  array-manipulation 
— Leaky Nun
source
1
Vous pouvez indiquer explicitement que ith est toujours indexé sur 1.
— Kevin Cruijssen
Faut-il vraiment manipuler le tableau? J'obtiens une réponse plus courte sans manipuler aucun tableau, produisant une sortie acceptable.
— Olivier Grégoire
2
@ OlivierGrégoire Vous n'avez pas à suivre les étapes, il vous suffit de produire la sortie dans un format raisonnable. (c'est-à-dire allez-y)
— Leaky Nun

Réponses:

6

Gelée , 9 octets

r€⁸Œp»\QṚ

Essayez-le en ligne!

Comment?

r€⁸Œp»\QṚ - Link: integer, N    e.g. 4
 €        - for €ach of implicit range of N (i.e. for i in [1,2,3,...N])
  ⁸       -   with the chain's left argument, N on the right:
r         -     inclusive range (for i<=N this yields [i, i+1, ..., N]
          - ...leaving us with a list of lists like the post-fixes of [1,2,3,....,N]
          -                     e.g. [[1,2,3,4],[2,3,4],[3,4],[4]]
   Œp     - Cartesian product* of these N lists
          -                     e.g. [[1,2,3,4],[1,2,4,4],[1,3,3,4],[1,3,4,4],[1,4,3,4],[1,4,4,4],[2,2,3,4],[2,2,4,4],[2,3,3,4],[2,3,4,4],[2,4,3,4],[2,4,4,4],[3,2,3,4],[3,2,4,4],[3,3,3,4],[3,3,4,4],[3,4,3,4],[3,4,4,4],[4,2,3,4],[4,2,4,4],[4,3,3,4],[4,3,4,4],[4,4,3,4],[4,4,4,4]]
      \   - cumulative reduce with:
     »    -   maximum (vectorises)
          -                     e.g. [[1,2,3,4],[1,2,4,4],[1,3,4,4],[1,3,4,4],[1,4,4,4],[1,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]
       Q  - de-duplicate        e.g. [[1,2,3,4],[1,2,4,4],[1,3,4,4],[1,4,4,4],[2,4,4,4],[3,4,4,4],[4,4,4,4]]
        Ṛ - reverse             e.g. [[4,4,4,4],[3,4,4,4],[2,4,4,4],[1,4,4,4],[1,3,4,4],[1,2,4,4],[1,2,3,4]]

* Il peut être plus facile de voir ce qui se passe avec le produit cartésien utilisé ci-dessus avec une entrée différente:

the Cartesian product of [[0,1,2],[3,4],[5]]
is [[0,3,5],[0,4,5],[1,3,5],[1,4,5],[2,3,5],[2,4,5]]
— Jonathan Allan
source
Vous avez surpassé les non-sur-golfeurs.
— Leaky Nun
5

R , 83 82 74 octets

N=rep(n<-scan(),n);while({print(N);any(K<-N>1:n)})N[x]=N[x<-which(K)[1]]-1

Essayez-le en ligne!

Au lieu d'une double boucle for, une whileboucle suffit ici: on trouve le premier index où la liste est supérieure à l'index, et on y décrémente.

Ka TRUEn'importe où N[i]>i, which(K)renvoie les vrais indices, et nous prenons le premier avec [1].

— Giuseppe
source
2

APL + WIN, 54 octets

Invite à saisir à l'écran un entier

((⍴m)⍴n)-+⍀m←0⍪(-0,+\⌽⍳n-1)⊖((+/+/m),n)↑m←⊖(⍳n)∘.>⍳n←⎕

Sort une matrice avec chaque ligne représentant le résultat de chaque étape, par exemple pour 4:

4 4 4 4
3 4 4 4
2 4 4 4
1 4 4 4
1 3 4 4
1 2 4 4
1 2 3 4
— Graham
source
2

Gelée , 11 octets

x`’Jḟḣ1Ʋ¦ÐĿ

Essayez-le en ligne!

Comment ça marche

x`’Jḟḣ1Ʋ¦ÐĿ  Main link. Argument: n

x`           Repeat self; yield an array of n copies of n.
         ÐĿ  While the results are unique, repeatedly call the link to the left.
             Return the array of all unique results, including the initial value.
  ’     ¦      Decrement the return value at all indices specified by the chain
               in between.
       Ʋ         Combine the four links to the left into a monadic chain.
   J               Indices; yield [1, ..., n].
    ḟ              Filterfalse; remove all indices that belong to the return value.
     ḣ1            Head 1; truncate the result to length 1.
— Dennis
source
2

Python 3 , 91 octets

n=int(input())
x=[n]*n;print(x)
for i in range(n):
    for j in[0]*(n-i-1):x[i]-=1;print(x)

Essayez-le en ligne!

— Dat
source
1 espace est suffisant pour indenter du code en python. Supprimer les espaces inutiles et passer à python 2 économise 10 octets: vérifiez-le
— Dead Possum
@DeadPossum, même si je sais que je pourrais faire mieux en Python 2, cela va bientôt être obsolète, donc je voulais pratiquer mes compétences Python 3 le plus possible.
— Dat
2

Java (OpenJDK 8) , 135 octets

a->{int r[]=new int[a],i=0;java.util.Arrays x=null;x.fill(r,a);for(r[0]++;i<a;r[i++]++)for(;--r[i]>i;System.out.print(x.toString(r)));}

Essayez-le en ligne!

Explication:

int r[]=new int[a],i=0;    //Initialize array and loop counter
java.util.Arrays x=null;    //reduces the number of of “Arrays” needed from 3 to 1
x.fill(r,a);    //Sets each value in array length n to int n
for(r[0]++;i<a;r[i++]++)    //Increment everything!
  for(;--r[i]>i;    //If decremented array element is larger than element number:
     System.out.print(x.toString(r)));}    //Print the array

Crédit:

-8 octets grâce à Jonathan Frech !

-16 octets grâce à Kevin Cruijssen !

-1 octet grâce à Okx !

— X1M4L
source
4
Le import java.util.*;fait partie du comptage d'octets que j'ai peur. Et le code de @ JonathanFrech peut être joué par 4 octets supplémentaires en mettant le ,i=0après le r[], et en changeant <-~aen <=a. ( Essayez-le en ligne. 144 octets ) (et j'ai changé ~-ipour i-1le rendre plus lisible ..)
— Kevin Cruijssen
1
139 octets en supprimant les import java.util.*;en utilisant java.util.Arrays x=null;et x.fillet x.toString. (Notez que votre solution actuelle est de 155 octets avec le nécessaireimport java.util.*;.)
— Kevin Cruijssen
1
Jouez un octet en utilisant for(;r[i-1]>i;plutôt que for(;r[i-1]!=i;.
— Okx
2
@KevinCruijssen Un autre octet pourrait être enregistré en jouant ++i<=aau golf i++<a.
— Jonathan Frech
1
Un autre octet -2 changeant la dernière partie en for(r[0]++;i<a;r[i++]++)for(;--r[i]>i;System.out.print(x.toString(r)));. :) Essayez-le en ligne 135 octets
— Kevin Cruijssen
2

Haskell, 69 67 65 63 octets

Définition récursive:

f 0=[[]]
f a=map(:(a<$[2..a]))[a,a-1..2]++[1:map(+1)x|x<-f$a-1]

Merci à Laikoni pour 2 octets!

— Angs
source
Le second mapest plus court de deux octets avec une compréhension de la liste: Essayez-le en ligne!
— Laikoni
2

PHP, 153 octets

Essayez-le en ligne!

Code 

function f($n){
$a=array_fill(0,$n,$n);$r=json_encode($a)."\n";$p=0;while($p<$n)
{if($a[$p]!=$p+1){$a[$p]--;$r.=json_encode($a)."\n";}else{$p++;}}echo$r;}

Je vais essayer de réduire les octets ou de terminer la fonction récursive

Explication

function f($n){
  $a=array_fill(0,$n,$n);          #start with $nlength array filled with $n
  $r=json_encode($a)."\n";         #pushed to the string to output
  $p=0;                            #first position
  while($p<$n){                    #on position $n ($n-1) we do nothing
    if($a[$p]!=$p+1){              #comparing the position+1 to the value
     $a[$p]--;                     #it gets decreased by 1
     $r.= json_encode($a)."\n";    #and pushed
   } else {
     $p++;                       #when position+1 = the value,
   }                               #position is changed ++
  }
   echo $r;
  }
— Francisco Hahn
source
Il semble que vous ayez des espaces inutiles donc cela devrait être de 153 octets - notez que je ne connais pas PHP.
— Giuseppe
oui, réalisez, merci, éditez maintenant.
— Francisco Hahn
1

J , 17 15 octets

+/\@,(#=)@i.&.-

Essayez-le en ligne!

Explication

+/\@,(#=)@i.&.-  Input: n
              -  Negate n
          i.     Reverse of range [0, n)
       =           Identity matrix of order n
      #            Copy each row by the reverse range
              -  Negate
    ,            Prepend n
+/\              Cumulative sum of rows
— miles
source
1

Rétine , 49 octets

.+
*
_
$`_,$= 
.{*\`_+,(_+)
$.1
0`(\b(_+),\2)_
$1

Essayez-le en ligne! Explication:

.+
*

Convertissez l'entrée en unaire.

_
$`_,$=

Créez une liste de n copies de i,noù iest l'index de la copie.

.

N'imprimez rien (lorsque la boucle se termine).

{

Boucle jusqu'à ce que le motif ne change pas.

*\`_+,(_+)
$.1

Supprimez temporairement le is et convertissez-le nen décimal et en sortie.

0`(\b(_+),\2)_
$1

Prenez la première entrée de liste dont la valeur dépasse son index et décrémentez-la.

— Neil
source
1

Python 3 , 70 67 65 octets

def f(n):
 k=0;a=[n]*n
 while k<n-1:print(a);k+=a[k]==k+1;a[k]-=1

Essayez-le en ligne!

  • (67) Conversion en fonction: -3 octets
  • (65) Suppression des parenthèses inutiles: -2 octets

Version non golfée:

def f(n):
    k = 0
    a = [n] * n             # create n-item list with all n's
    while k < n - 1:        # iterate through columns 0..n-1
        print(a)            # print whole list
        if a[k] == k + 1:   # move to the next column when current item reaches k+1
            k += 1
        a[k] -= 1           # decrement current item
— xbarbie
source
0

C (clang) , 131 141 octets

i,j,k,m[99];p(){for(k=0;m[k];printf("%d ",m[k++]));puts("");}f(n){for(j=k=m[n]=0;k<n;m[k++]=n);p();for(;j<n;j++)for(i=1;i++<n-j;m[j]--,p());}

Essayez-le en ligne!

Cela fonctionnera pour tous njusqu'à 99. TIO tronque la sortie. Il peut prendre en charge arbitrairement plus grand nen modifiant la taille du tableau msi la mémoire le permet.

Le suivi est limité à n = 1..9 mais est significativement plus court

C (clang) , 89 92 octets

i,j;char m[12];f(n){j=!puts(memset(m,n+48,n));for(;j<n;j++)for(i=1;i++<n-j;m[j]--,puts(m));}

Essayez-le en ligne!

Mise à jour: modifiée pour éviter la dépendance à l'initialisation statique

— GPS
source
Votre static/global initialization because multiple test casesn'est pas autorisé, car les fonctions doivent pouvoir être appelées plusieurs fois.
— Jonathan Frech
@Jonathan Mise à jour des réponses. Je me suis toujours demandé si cela devait être autorisé et je ne pouvais pas me décider.
— GPS
1
Voici le méta post pertinent: codegolf.meta.stackexchange.com/a/4940/73111
— Jonathan Frech
Vous pouvez jouer m[j]--,p()au golf p(m[j]--)et enregistrer un octet.
— Jonathan Frech
— plafondcat
0

Clojure, 132 octets

#(loop[R[(vec(repeat % %))]j(- % 2)i 0](if(> i j)R(recur(conj R(update(last R)i dec))(if(= i j)(- % 2)(dec j))(if(= i j)(inc i)i))))

J'espérais que ce serait plus court ...

Moins dynamique mais plus long à 141 octets:

#(apply map list(for[i(range %)](concat(repeat(nth(cons 0(reductions +(reverse(range %))))i)%)(range % i -1)(if(>(dec %)i)(repeat(inc i))))))
— NikoNyrh
source
0

Python 3, 101 octets

def f(n):
 p=print;m=[n for_ in range(n)];p(m)
 for i in range(n):
    while m[i]>1+i:m[i]-=1;p(m)

Je pourrais probablement jouer davantage au golf avec l'impression, mais je suis loin de mon ordinateur et je ne suis pas entièrement sûr des règles de python 2 sur la définition d'une variable à imprimer. Je mettrai à jour plus tard quand j'arriverai à un ordinateur ou si quelqu'un clarifie dans les commentaires.

— sonrad10
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.