Tornar um programa de triangularidade válido


19

Triangularity é um novo esolang desenvolvido pelo Sr. Xcoder, onde a estrutura do código deve seguir um padrão muito específico:

  • Para a nlinha de código th, deve haver exatamente 2n-1caracteres do programa. Isso causa uma forma triangular / pirâmide, com a primeira linha tendo apenas um caractere e o restante aumentando em incrementos de 2.
  • Cada linha deve ser preenchida com .s à esquerda e à direita, de modo que os caracteres sejam centralizados em suas linhas e todas as linhas sejam preenchidas no mesmo comprimento. Se lfor definido como o número de linhas no programa, cada linha no programa deverá ter um comprimento de2 * l - 1

Por exemplo, o programa à esquerda é válido, mas o programa à direita não é:

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

Quando disposto na estrutura válida, o nome se torna óbvio.

Tarefa

Sua tarefa é pegar uma string de linha única como entrada, representando o código de Triangularidade, e produzi-la em código válido, conforme descrito acima.

Especificações para E / S:

  • A entrada conterá apenas caracteres no intervalo 0x20 - 0x7e
  • O comprimento da entrada sempre será um número quadrado e, portanto, agradável.
  • Você deve usar pontos para o preenchimento de saída, e não outra coisa.

Você pode inserir e enviar através de qualquer método aceitável . Este é um portanto o código mais curto em bytes vence!

Casos de teste

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

Para quem conhece a triangularidade, notará no último caso de teste que as strings não precisam ser manipuladas



13
Sei que isso é provavelmente fútil, mas será que o rebaixador se importaria em explicar seu voto? Eu adoraria melhorar o desafio da maneira que puder.
caird coinheringaahing

As novas linhas iniciais ou finais são aceitáveis?
Arnauld 04/02

@ Arnauld Sim, o espaço em branco à esquerda e à direita está perfeitamente bem.
caird coinheringaahing

Uma lista de linhas está correta?
Mr. Xcoder

Respostas:


19

Triangularidade , 127 bytes

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

Experimente online!

Explicação

Removendo os caracteres que compensam o preenchimento, obtemos o seguinte programa:

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

... Qual é o comprimento total, certo? Vamos dividi-lo em pedaços.

Gerando os números inteiros [0… len (entrada))

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

Gerando os pontos

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

Aparar os caracteres na frente

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.

Aparando os caracteres no final

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.

Terminando o loop e imprimindo bonita

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

você precisa pontuar bytes para o "." caracteres se eles são mandatados pelos intrínsecos da linguagem?
JDL

@JDL Sim, o programa não pode funcionar corretamente sem eles, então eu devo incluí-los na contagem de bytes :-)
Mr. Xcoder

Você precisa "aparar decimais", visto que o comprimento da entrada é garantido como quadrado? Você também deve conseguir obter o bastão Jno final e gerar uma série de linhas. Porém, não sei se isso vai lhe poupar alguma coisa, se o final da última linha precisa ser preenchido .para preencher o espaço restante.
Shaggy

1
@ Shaggy 1) Sim, fé necessário porque o intervalo não pode aceitar argumentos de flutuação (mesmo com .0) 2) Livrar-se de Jnão salva nenhum bytes devido ao preenchimento, então escolhi o formato de saída mais bonito.
Sr. Xcoder 5/02

8

Japonês , 15 14 10 bytes

Produz uma matriz de linhas.

ò@°T¬v1Ãû.

Experimente | Verifique todos os casos de teste


Explicação

ò@     Ã       :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

Solução original

ʬÆsTT±X+°XÃû.

Tente

Ê                  :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

Casca , 15 bytes

Ṡzö`JR2tR'.ṡCİ1

Experimente online!

Explicação

Ṡ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 bytes

Guardou um byte graças a Magic Octopus Urn

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

Experimente online!

Explicação

ā                    # 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

ÅÉpor probabilidades pode ajudar?
Magic Octopus Urn

Algo como g;ÅÉ£Rvy'.N×.ø}r»,? Mas não é porque isso não está certo, lol.
Urna de polvo mágico

@MagicOctopusUrn: ÅÉajudaria definitivamente se pudéssemos descobrir o comprimento da linha inferior em 2 bytes. Eu não sei se podemos, no entanto. Pode ser outra maneira de incorporá-lo também.
Emigna

@MagicOctopusUrn: Eu tinha essa mesma solução anterior, excepto que eu usei )Rem vez de rque não salvou nenhum bytes: /
Emigna

Eu estava tentando encontrar uma maneira de "reverter o loop" para apenas imprimir à medida que ocorre, embora não haja idéias sobre isso.
Magic Octopus Urn


5

Geléia ,  22  19 bytes

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

Um link monádico retornando uma lista de listas de caracteres (as linhas)

Experimente online!

Quão?

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 bytes

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

Casos de teste

Comentado

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

[menor] o símbolo '/ n' se tornou uma quebra de linha real no bloco de código na parte superior - considere escapar dele para maior clareza :) #
G0BLiN

@ G0BLiN Esta é a outra maneira: é de fato uma quebra de linha literal no código golfado, que foi substituída por uma quebra de linha escapada na versão desmontada para maior clareza. :)
Arnauld

Ha, piada em mim, então ... :-)
G0BLiN


2

MATL , 21 bytes

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

Experimente online!

Explicação

Considere a entrada 'DfJ0vCq7G'como um exemplo. O conteúdo da pilha é mostrado separado por vírgulas, com o último elemento por último. Linhas em uma matriz 2D usam ponto e vírgula como separador.

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

Limpo , 107 94 89 88 bytes

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

@[]1

Experimente online! Exemplo de utilização: @[]1 ['ABCDEF"$%& G8"F@'].



1

Perl, 56 52 bytes

Inclui +3para-p

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

Dê entrada no STDIN (em princípio sem nova linha final, mas isso só importa para a entrada vazia)


1
de acordo com as regras do PCG -pcusta apenas 1 byte
mik:

@ mik Somente se o código não contiver '. Mas esse código faz, portanto ele precisa ser colocado em um arquivo (ou escapando na linha de comando) que precisa de 3 caracteres extras em comparação com a #!linha normal . Portanto, neste caso, é +3(para código normal você vai ver Eu, na verdade só contam +para p)
Ton Hospel

1

Vermelho , 227 203 bytes

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]]]

Experimente online!

Ungolfed:

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

Retina , 88 72 71 bytes

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

Experimente online! Edit: Salvo 12 13 bytes graças a @MartinEnder. Explicação:

S1`

Divida o primeiro personagem em sua própria linha para fazer a bola rolar.

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

Pique cada linha com dois caracteres a mais que o anterior.

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

Esquerda na primeira metade de cada linha, centralizando-as efetivamente.

P'.`.+

Botão direito do mouse em todas as linhas.


1

Carvão , 21 19 bytes

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

Experimente online! Link é a versão detalhada do código. Editar: salvou 2 bytes ao descobrir SquareRoot. Explicação:

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

: / Isso quase funciona, mas parece que o carvão é um pouco buggy. Isso funciona, eu acho?
somente ASCII

@ Somente ASCII ... que magia negra é essa?
Neil

O preenchimento verifica basicamente bytes nulos (ou seja, o caractere usado para o espaço onde nada é desenhado), para que você possa desenhar um polígono com bytes nulos (bem, se ele funcionar corretamente> _>) e preenchê-lo. Obviamente, isso não é exatamente o pretendido, pois você pode realmente ver os bytes nulos antes do preenchimento por algum motivo> _>
somente ASCII

esta deve funcionar corretamente próxima atração
ASCII-only



0

Ruby , 73 66 bytes

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

Experimente online!

-5 bytes: Retorna uma matriz de strings em vez de imprimi-las

-2 bytes: declarar z no lugar em vez de antecipadamente

Ungolfed:

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

Declarar uma variável r=q-1para que eu possa pegar s[r*r...q*q]salva exatamente zero bytes.

Usar em .centervez de preencher manualmente também economiza zero bytes, mas eu gosto mais.


Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.