Una stringa la cui lunghezza è un numero triangolare positivo (1, 3, 6, 10, 15 ...) può essere disposta in un "triangolo del testo equilatero" aggiungendo alcuni spazi e nuove linee (e mantenendolo nello stesso ordine di lettura).

Ad esempio, la stringa di lunghezza 10 ABCDEFGHIJdiventa:

   A
  B C
 D E F
G H I J

Scrivi un programma o una funzione che accetta una tale stringa, tranne che conterrà solo i caratteri 0e 1. (Si può presumere che l'input sia valido.)

Per il risultante "triangolo del testo equilatero", output (stampa o ritorno) uno dei quattro numeri che indica il tipo di simmetria esibita:

• Uscita 2se il triangolo ha simmetria bilaterale. cioè ha una linea di simmetria da qualsiasi angolo al punto medio del lato opposto.

  Esempi:

   0
  1 1
  
   1
  0 1
  
    0
   0 1
  0 1 0
  
     1
    1 1
   1 0 1 
  0 1 1 1
  

• Emissione 3se il triangolo ha simmetria rotazionale. cioè poteva essere ruotato di 120 ° senza alcun cambiamento visivo.

  Esempi:

     0
    1 0
   0 1 1
  0 1 0 0
  
     0
    0 1
   1 0 0
  0 0 1 0
  
      1
     0 1
    1 1 1
   1 1 1 0
  1 0 1 1 1
  
       1
      0 1
     0 0 1
    1 0 0 0
   1 0 0 0 0
  1 0 0 1 1 1
  

• Output 6se il triangolo ha sia simmetria bilaterale e rotazionale. cioè soddisfa le condizioni per la produzione di entrambi 2e 3.

  Esempi:

  0
  
  1
  
   0
  0 0
  
    1
   0 0
  1 0 1
  
     0
    0 0
   0 1 0
  0 0 0 0
  

• Uscita 1se il triangolo non ha simmetria bilaterale né rotazionale.

  Esempi:

    1
   1 0
  0 0 0
  
    0
   0 1
  1 0 1
  
     1
    1 0
   1 1 1 
  1 1 1 1
  
      1
     1 1
    1 1 1 
   0 0 0 1
  1 1 1 1 1
  

Vince il codice più breve in byte. Tiebreaker è la risposta precedente.

A parte una nuova riga finale facoltativa, la stringa di input potrebbe non avere spaziatura o struttura di spaziatura / riga nuova - dovrebbe essere semplice 0e normale 1.

Se lo si desidera, è possibile utilizzare due caratteri ASCII stampabili distinti al posto di 0e 1.

Casi test

Tratto direttamente dagli esempi.

011 -> 2
101 -> 2
001010 -> 2
1111010111 -> 2
0100110100 -> 3
0011000010 -> 3
101111111010111 -> 3
101001100010000100111 -> 3
0 -> 6
1 -> 6
000 -> 6
100101 -> 6
0000100000 -> 6
110000 -> 1
001101 -> 1
1101111111 -> 1
111111000111111 -> 1

"Ruotando" qualsiasi input di 120 ° si otterrà ovviamente lo stesso output.

CJam, 37 29 28 27 byte

Grazie a SP3000 per il salvataggio 3 byte.

q{T):T/(\s}h]{z_Wf%_}3*])e=

Suite di test.

Questo riutilizza alcuni trucchi di rotazione triangolo da questa sfida .

Questo funziona anche per lo stesso conteggio byte:

q{T):T/(\s}h]3{;z_Wf%_}%)e=

Spiegazione

In primo luogo, un breve riepilogo dal post triangolo ho linkato sopra. Rappresentiamo un triangolo come 2D (ragged) lista, es

[[0 1 1]
 [0 0]
 [0]]

Il gruppo di simmetria del triangolo ha 6 elementi. Esistono cicli di lunghezza 3 ruotando il triangolo e cicli di 2 specchiandolo lungo alcuni assi. Convenientemente, le rotazioni corrispondono a due diverse riflessioni. Per fare ciò utilizzeremo le seguenti riflessioni:

1. Trasporre l'elenco significa rifletterlo lungo la diagonale principale, in modo da ottenere:

   [[0 0 0]
    [1 0]
    [1]]
   

2. L'inversione di ogni riga rappresenta un riflesso che scambia i due angoli superiori. Applicando questo al risultato della trasposizione otteniamo:

   [[0 0 0]
    [0 1]
    [1]]
   

Usando queste due trasformazioni e mantenendo il risultato intermedio, possiamo generare tutte e sei le simmetrie dell'input.

Un ulteriore punto da notare è il comportamento della trasposizione in un elenco come questo:

[[0]
 [1 0]
 [1 0 0]
 []]

Perché è quello che finiremo dopo aver diviso l'input. Convenientemente, dopo la trasposizione, CJam svuota tutte le linee a sinistra, il che significa che questo effettivamente elimina l'estraneo []e lo porta in una forma che è utile per le due trasformazioni sopra (tutte senza cambiare la disposizione effettiva del triangolo oltre la simmetria riflettente):

[[0 1 1]
 [0 0]
 [0]]

Detto questo, ecco il codice:

q       e# Read input.
{       e# While the input string isn't empty yet...
  T):T  e#   Increment T (initially 0) and store it back in T.
  /     e#   Split input into chunks of that size.
  (     e#   Pull off the first chunk.
  \s    e#   Swap with remaining chunks and join them back together
        e#   into a single string.
}h
]       e# The stack now has chunks of increasing length and an empty string
        e# as I mentioned above. Wrap all of that in an array.
{       e# Execute this block 3 times...
  z_    e#   Transpose and duplicate. Remember that on the first iteration
        e#   this gets us a triangle of the desired form and on subsequent
        e#   iterations it adds one additional symmetry to the stack.
  Wf%_  e#   Reverse each row and duplicate.
}3*
        e# The stack now has all 6 symmetries as well as a copy of the
        e# last symmetry.
]       e# Wrap all of them in a list.
)       e# Pull off the copy of the last symmetry.
e=      e# Count how often it appears in the list of symmetries.