Rendre un programme triangulaire valide


19

La triangularité est un nouvel esolang développé par M. Xcoder où la structure du code doit suivre un modèle très spécifique:

  • Pour la ne ligne de code, il doit y avoir exactement des 2n-1caractères du programme. Cela provoque une forme triangulaire / pyramide, la première ligne n'ayant qu'un seul caractère et le reste augmentant par incréments de 2.
  • Chaque ligne doit être remplie de .s à gauche et à droite, de sorte que les caractères soient centrés sur leurs lignes et que toutes les lignes soient remplies à la même longueur. Si lest défini comme le nombre de lignes du programme, chaque ligne du programme doit avoir une longueur de2 * l - 1

Par exemple, le programme de gauche est valide, mais le programme de droite n'est pas:

 Valid    |  Invalid  
          |
...A...   |  ABCDE
..BCD..   |  FGH
.EFGHI.   |  IJKLMN
JKLMNOP   |  OPQRS

Lorsqu'il est disposé dans la structure valide, le nom devient évident.

Tâche

Votre tâche consiste à prendre une chaîne de ligne unique en entrée, représentant le code de triangulation, et à la convertir en code valide comme décrit ci-dessus.

Spécifications pour les E / S:

  • L'entrée ne contiendra que des caractères dans la plage 0x20 - 0x7e
  • La longueur de l'entrée sera toujours un nombre carré et donc bien remplissable.
  • Vous devez utiliser des points pour le remplissage de sortie, pas autre chose.

Vous pouvez entrer et sortir par n'importe quelle méthode acceptable . C'est un donc le code le plus court en octets gagne!

Cas de test

input
----
output

g
----
g

PcSa
----
.P.
cSa

DfJ0vCq7G
----
..D..
.fJ0.
vCq7G

7xsB8a1Oqw5fhHX0
----
...7...
..xsB..
.8a1Oq.
w5fhHX0

QNYATbkX2sKZ6IuOmofwhgaef
----
....Q....
...NYA...
..TbkX2..
.sKZ6IuO.
mofwhgaef

ABCDEF"$%& G8"F@
----
...A...
..BCD..
.EF"$%.
& G8"F@

ab.c
----
.a.
b.c

Pour ceux qui connaissent la triangulation, vous remarquerez dans le dernier cas de test que les chaînes n'ont pas à être gérées



13
Je me rends compte que c'est probablement futile, mais est-ce que les votants voudraient expliquer leur vote? J'adorerais améliorer le défi de toutes les manières possibles.
caird coinheringaahing

Les sauts de ligne de début ou de fin sont-ils acceptables?
Arnauld

@Arnauld Oui, les espaces blancs de début et de fin conviennent parfaitement.
caird coinheringaahing

Une liste de lignes est-elle correcte?
M. Xcoder

Réponses:


19

Triangularité , 127 octets

.......).......
......2)1......
...../)IL^.....
....f)rMD@_....
...)2)1/)IL^...
..f+`"'.'*"+E..
.DWReD)2s^)Its.
D+@sh+s+})10cJ.

Essayez-le en ligne!

Explication

En supprimant les caractères qui composent le remplissage, nous obtenons le programme suivant:

)2)1/)IL^f)rMD@_)2)1/)IL^f+`"'.'*"+EDWReD)2s^)ItsD+@sh+s+})10cJ

... Ce qui est assez long, non? Décomposons-le en morceaux.

Génération des entiers [0… √len (entrée))

)2)1/)IL^f)r – Subprogram #1.
)            – Creates a new stack entry, equal to 0. This must precede any integer
               literal, because each character in '0123456789' isn't parsed on its
               own as a literal, but rather they are commands which multiply the ToS
               by 10 and add the value of their digit equivalent. 
 2           – ToS * 10 + 2 = 2.           || STACK: [2]
  )1         – The literal 1.              || STACK: [2, 1]
    /        – Division.                   || STACK: [1 / 2] = [0.5]
     )I      – Get the input at index 0.   || STACK: [0.5, input]
       L     – Length.                     || STACK: [0.5, len(input)]
        ^    – Exponentiation.             || STACK: [len(input) ** 0.5]
         f   – Trim decimals.              || STACK: [int(len(input) ** 0.5)] 
          )r – Create the list [0 .. ToS). || STACK: [[0 ... int(len(input) ** 0.5))]

Générer les points

MD@_)2)1/)IL^f+`"'.'*"+E – Subprogram #2.
MD                       – For each integer in the range, run some code on a separate
                           stack, preinitialised to two copies of the argument.
  @_                     – Increment and negate the ToS.
    )2)1/)IL^f           – The square root of the length of the input, again.
              +          – Add the two.
               `         – And cast the integer given to a string.
                "'.'*"+  – Prepends the literal "'.'*" to the string representation.
                       E – Evaluate as a Python expression (basically string repetition).

Découper les personnages à l'avant

DWReD)2s^)It – Subprogram #3.
D            – Duplicate the result of the expression above.
 W           – Wrap the whole intermediate stack to an array.
  Re         – Reverse the stack and dump the contents separately onto the stack.
    D        – Duplicate the result.
     )2      – Push the literal 2.
       s^    – Swap and perform exponentiation.
         )It – Push the input and trim the characters before that index.

Découper les caractères à la fin

sD+@sh+s+ – Subprogram #4.
s         – Swap the top two elements on the stack.
 D+       – Double. Push twice and add.
   @      – Increment.
    sh    – Swap the top two elements and trim the characters after that index.
      +   – Append the first set of dots.
       s+ – And prepend the second set of dots.

Fin de la boucle et jolie impression

})10cJ – Subprogram #5.
}      – End the loop.
 )10   – Push the literal 10.
    c  – Convert from code-point to character (yields '\n').
     J – And join the result by newlines.

devez-vous marquer des octets pour le "." caractères s'ils sont mandatés par les intrinsèques de la langue?
JDL

@JDL Oui, le programme ne peut pas fonctionner correctement sans eux, je dois donc les inclure dans le nombre d'octets :-)
M. Xcoder

Avez-vous besoin de "découper les décimales", étant donné que la longueur de l'entrée est garantie carrée? Vous devriez également pouvoir obtenir la tige de Jla fin et afficher un tableau de lignes. Je ne sais pas si cela va vous sauver quoi que ce soit, si la fin de la dernière ligne doit être remplie .pour remplir l'espace restant.
Shaggy

1
@Shaggy 1) Oui, fc'est nécessaire car la plage ne peut pas accepter d'arguments flottants (même avec .0) 2) Se débarrasser de Jne permet pas d'économiser d'octets en raison du rembourrage, j'ai donc choisi le format de sortie le plus joli.
M. Xcoder

8

Japt , 15 14 10 octets

Génère un tableau de lignes.

ò@°T¬v1Ãû.

Essayez-le | Vérifier tous les cas de test


Explantion

ò@     Ã       :Partition at characters where the following function returns true
  °T           :  Increment T (initially 0)
    ¬          :  Square root
     v1        :  Divisible by 1?
               :(Or, in other words, split after every character with a 1-based index that's a perfect square)
        û.     :Centre pad each element with .s to the length of the longest element

Solution originale

ʬÆsTT±X+°XÃû.

Essayez-le

Ê                  :Length of input
 ¬                 :Square root
  Æ        à       :Range [0,ʬ) and pass each X through a function
   s               :  Slice input
    T              :    from index T, initially 0
     T±X+°X        :    to index T incremented by X plus X incremented
            û.     :Centre pad each element with .s to the length of the longest element

7

Husk , 15 octets

Ṡzö`JR2tR'.ṡCİ1

Essayez-le en ligne!

Explication

Ṡzö`JR2tR'.ṡCİ1  Implicit input, say s = "DfJ0vCq7G".
             İ1  List of odd positive integers: [1,3,5,7,..
            C    Cut s to those lengths: x = ["D","fJ0","vCq7G"]
           ṡ     Reversed indices of x: y = [3,2,1]
Ṡz               Zip x and y using this function:
                  Arguments are a string and a number, e.g. r = "fJ0" and n = 2.
        R'.       n copies of '.': ".."
       t          Drop first element: "."
     R2           Two copies of this: [".","."]
  ö`J             Join by r: ".fJ0."
                 Result is ["..D..",".fJ0.","vCq7G"]; implicitly print on separate lines.

7

05AB1E , 20 19 18 octets

Un octet enregistré grâce à l' urne Magic Octopus

ā·<£õKRvy'.N×.ø}r»

Essayez-le en ligne!

Explication

ā                    # push the list [1 ... len(input)]
 ·<                  # multiply each by 2 and decrement each, making a list of odd numbers
   £                 # split the input into chunks of these sizes
    õK               # remove empty strings
      R              # reverse list
       vy      }     # for each y in the list
             .ø      # surround it with
         '.N×        # "." (dot) repeated N times, where N is the current iteration index
                r    # reverse the stack
                 »   # join stack by newlines

ÅÉpour les cotes peut aider?
Magic Octopus Urn

Quelque chose comme g;ÅÉ£Rvy'.N×.ø}r»,? Mais pas parce que ce n'est pas vrai lol.
Urne de poulpe magique

@MagicOctopusUrn: ÅÉserait certainement utile si nous pouvions trouver la longueur de la ligne du bas en 2 octets. Je ne sais pas si nous pouvons cependant. Cela pourrait aussi être une autre façon de l'incorporer.
Emigna

@MagicOctopusUrn: J'ai eu cette même solution plus tôt, sauf que j'ai utilisé )Rau lieu de rcela n'a pas enregistré d'octets: /
Emigna

J'essayais de trouver un moyen de "renverser la boucle" pour simplement imprimer au fur et à mesure, mais aucune idée à ce sujet.
Urne de poulpe magique


5

Gelée ,  22  19 octets

J²‘Ṭœṗ⁸Ṛz”.Zµṙ"JC$Ṛ

Un lien monadique renvoyant une liste de listes de personnages (les lignes)

Essayez-le en ligne!

Comment?

J²‘Ṭœṗ⁸Ṛz”.Zµṙ"JC$Ṛ - Link: list of characters e.g. "DfJ0vCq7G"
J                   - range of length               [1,2,3,4,5,6,7,8,9]
 ²                  - square (vectorises)           [1,4,9,16,25,36,49,64,81]
  ‘                 - increment                     [2,5,10,17,26,37,50,65,82]
   Ṭ                - untruth (1s at those indices) [0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,...]
      ⁸             - chain's left argument         "DfJ0vCq7G"
    œṗ              - partition at indexes          ["D","fJ0","vCq7G"]
       Ṛ            - reverse                       ["vCq7G","fJ0","D"]
         ”.         - literal '.'                   '.'
        z           - transpose with filler         ["vfD","CJ.","q0.","7..","G.."]
           Z        - transpose                     ["vCq7G","fJ0..","D...."]
            µ       - start a new monadic chain
                 $  - last two links as a monad:
               J    -   range of length             [1,2,3]
                C   -   complement (vectorises)     [0,-1,-2]
              "     - zip with:
             ṙ      -   rotate left by              ["vCq7G",".fJ0.","..D.."]
                  Ṛ - reverse                       ["..D..",".fJ0.","vCq7G"]

5

JavaScript (ES7), 82 78 octets

f=(s,k=1-s.length**.5*2,p='')=>s&&f(s.slice(0,k),k+2,p+'.')+`
`+p+s.slice(k)+p

Cas de test

Commenté

f = (                       // f = recursive function taking:
  s,                        //   s = input string
  k = 1 - s.length**.5 * 2, //   k = additive inverse of the length of the base
  p = ''                    //   p = padding string
) =>                        //
  s &&                      // if s is not empty:
    f(                      //   do a recursive call with:
      s.slice(0, k),        //     s without the last -k characters
      k + 2,                //     the updated base length (2 less characters)
      p + '.'               //     the updated padding string
    ) +                     //   end of recursive call()
    `\n` +                  //   append a line feed
    p +                     //   append the left padding string
    s.slice(k) +            //   append the last -k characters of s
    p                       //   append the right padding string

[mineur] le symbole '/ n' est devenu un véritable saut de ligne dans le bloc de code en haut - pensez à y échapper pour plus de clarté :)
G0BLiN

@ G0BLiN C'est l'inverse: il s'agit en effet d'un saut de ligne littéral dans le code golfé, qui a été remplacé par un saut de ligne échappé dans la version non golfée pour plus de clarté. :)
Arnauld

Ha, la blague est sur moi, alors ... :-)
G0BLiN


2

MATL , 21 octets

tnX^eRP&1ZvGyg(46y~(!

Essayez-le en ligne!

Explication

Considérez l'entrée 'DfJ0vCq7G'comme exemple. Le contenu de la pile est affiché séparé par des virgules, avec l'élément supérieur en dernier. Les lignes d'un tableau 2D utilisent un point-virgule comme séparateur.

t      % Implicit input: string. Duplicate
       % STACK: 'DfJ0vCq7G',
                'DfJ0vCq7G'
nX^    % Number of elements. Square root
       % STACK: 'DfJ0vCq7G',
                3
e      % Reshape with that many rows (in column major order)
       % STACK: ['D0q';
                 'fv7';
                 'JCG']
R      % Upper triangular part: set elements below diagonal to char(0)
       % (displayed as space)
       % STACK: ['D0q';
                 ' v7';
                 '  G']
P      % Flip vertically
       % STACK: ['  G';
                 ' v7';
                 'D0q']
&1Zv   % Reflect vertically
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G']
G      % Push input again
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                'DfJ0vCq7G'
yg     % Duplicate from below and convert to logical. This gives true for
       % for nonzero chars (the entries where input chars will be written)
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                'DfJ0vCq7G',
                [0 0 1;
                 0 1 1;
                 1 1 1;
                 0 1 1;
                 0 0 1]
(      % Assignment indexing: write values at those positions
       % STACK: ['  v';
                 ' fC';
                 'DJq';
                 ' 07';
                 '  G']
46     % Push 46, which is ASCII for '.'
       % STACK: ['  v';
                 ' fC';
                 'DJq';
                 ' 07';
                 '  G'],
                 46
y~     % Duplicate from below and apply logical negate. This gives true
       % for char(0) (the entries where '.' will be written)
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                46
                [1 1 0;
                 1 0 0;
                 0 0 0;
                 1 0 0;
                 1 1 0]
(      % Assignment indexing: write value at those positions
       % STACK: ['..G';
                 '.v7';
                 'D0q';
                 '.v7';
                 '..G'],
!      % Transpose. Implicit display
       % STACK: ['..D..';
                 '.fJ0.';
                 'vCq7G']

2

Propre , 107 94 89 88 octets

import StdEnv
@s _[]=s
@s n r= @([['.':l]++['.']\\l<-s]++[take n r])(n+2)(drop n r)

@[]1

Essayez-le en ligne! Exemple d' utilisation: @[]1 ['ABCDEF"$%& G8"F@'].


1

Haskell , 84 68 octets

[]%1
(s%n)[]=s
(s%n)r=(['.':l++"."|l<-s]++[take n r])%(n+2)$drop n r

Essayez-le en ligne!

Exemple d'utilisation: []%1 $ "abcd"donne la liste des lignes [".a.","bcd"].


1

Perl, 56 52 octets

Comprend +3pour-p

#!/usr/bin/perl -p
$_=("."x y///c**.5)=~s%.%$'@{[$&x/$`$`./g]}$'
%rg

Donner une entrée sur STDIN (en principe sans nouvelle ligne finale, mais cela n'a d'importance que pour l'entrée vide)


1
selon les règles du PCG ne -pcoûte que 1 octet
mik

@mik Uniquement si le code ne contient pas '. Mais ce code le fait, il doit donc être placé dans un fichier (ou s'échapper sur la ligne de commande) qui nécessite 3 caractères supplémentaires par rapport à la #!ligne normale . Donc dans ce cas c'est le cas +3(pour le code normal, vous verrez que je ne compte en effet que +pour p)
Ton Hospel

1

Rouge , 227 203 octets

f: func[s][l: to-integer(length? s)** 0.5
n: 0 foreach m parse s[collect[(r: []repeat i l[append r reduce['keep i * 2 - 1
charset[not{Я}]]])r]][v: copy""insert/dup v"."l - n: n + 1 print rejoin[v m v]]]

Essayez-le en ligne!

Non golfé:

f: func[s][
l: to-integer (length? s) ** 0.5
n: 0
foreach m parse s [ 
    collect [
        (r: []
        repeat i l [ append r reduce [
            'keep i * 2 - 1 charset [ not{Я} ]]])
    r ]] 
    [v: copy ""
    insert/dup v "." l - n: n + 1
    print rejoin [v m v]]
]

1

Rétine , 88 72 71 octets

S1`
+m`^(.)+¶(?>(?<-1>.)+)..(?!¶)
$&¶
P^'.m`^.(?=(..)*)(?<-1>.)*
P'.`.+

Essayez-le en ligne! Edit: enregistré 12 13 octets grâce à @MartinEnder. Explication:

S1`

Divisez le premier personnage sur sa propre ligne pour faire rouler la balle.

+m`^(.)+¶(?>(?<-1>.)+)..(?!¶)
$&¶

Coupez chaque ligne de deux caractères de plus que la précédente.

P^'.m`^.(?=(..)*)(?<-1>.)*

Appuyez à gauche sur la première moitié de chaque ligne, en les centrant efficacement.

P'.`.+

Appuyez à droite sur toutes les lignes.


1

Fusain , 21 19 octets

UB.F₂Lθ«P✂θXι²X⊕ι²↙

Essayez-le en ligne! Le lien est vers la version détaillée du code. Edit: enregistré 2 octets en découvrant SquareRoot. Explication:

UB.                 Set the background fill to `.`
      θ             (First) input
     L              Length
    ₂               Square root
   F   «            Loop over implicit range
            ι   ι   Current value
               ⊕    Incremented
             ²   ²  Literal 2
           X  X     Power
         ✂θ         Slice the (first) input string
        P           Print without moving the cursor
                  ↙ Move down left

: / Cela fonctionne presque mais il semble que le charbon soit un peu bogué. Cela fonctionne bien, je pense?
ASCII uniquement le

@ ASCII uniquement ... de quelle magie noire s'agit-il?
Neil

Fill vérifie essentiellement les octets nuls (c'est-à-dire le caractère utilisé pour l'espace où rien n'est dessiné), vous pouvez donc simplement dessiner un polygone avec des octets nuls (enfin, si cela fonctionne même correctement> _>) et le remplir. De toute évidence, ce n'est pas exactement prévu car vous pouvez réellement voir les octets nuls avant même le remplissage pour une raison quelconque> _>
ASCII uniquement

cela devrait fonctionner correctement lors de la prochaine extraction
ASCII uniquement



0

Rubis , 73 66 octets

->s{(1..z=s.size**0.5).map{|q|s[q*q-2*q+1...q*q].center 2*z-1,?.}}

Essayez-le en ligne!

-5 octets: retourne un tableau de chaînes au lieu de les imprimer

-2 octets: déclarer z en place au lieu d'avance

Non golfé:

->s{
  (1..z=s.size**0.5).map{|q|   # Map the range [1,sqrt(s.size)]
    s[q*q-2*q+1...q*q]         # To the relevant portion of s,
      .center 2*z-1, ?.        #   padded left and right with . characters
  }
}

Déclarer une variable r=q-1pour que je puisse prendres[r*r...q*q] enregistre exactement zéro octet.

L'utilisation .centerau lieu du remplissage manuellement permet également d'économiser zéro octet, mais je l'aime mieux.


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.