In questa variante di quine, il tuo programma deve emettere il suo codice sorgente trasposto attraverso la diagonale dalla parte superiore sinistra a quella inferiore destra. Per esempio:

il tuo programma
su
quattro righe

uscite

 yof
 ono
 u u
 r r
    
 p l
 r i
 o n
 g e
 r s
 a
 m

Lo spazio bianco nell'output non è arbitrario. Gli spazi vengono visualizzati in due situazioni: dove c'è uno spazio nell'originale (ad esempio tra re lnella quarta colonna) e dove è necessario riempire i caratteri (ad esempio tutti gli spazi nella prima colonna.) Entrambi sono richiesti e gli spazi non possono apparire da nessuna parte altro nell'output.

È possibile ignorare facoltativamente una singola nuova riga finale nell'output. Le nuove righe finali nel codice sorgente non hanno alcun effetto sull'output e le nuove righe principali nel codice sorgente devono essere gestite come nell'esempio precedente. Supponiamo che ogni personaggio che non sia una nuova riga sia largo una colonna e alto una riga, anche se per i caratteri come tab questo può portare a un brutto risultato.

La soluzione deve avere almeno due righe con almeno due caratteri non di nuova riga ciascuno e non deve essere una propria trasposizione (l'output non può essere identico alla sorgente).

Non sono consentiti cheat quines che leggono dal file che contiene il loro codice sorgente, estraggono i dati da un URL, usano i quining integrati e così via.

Questo è il codice golf: vince il codice più corto in byte.

CJam, 14 byte

{`"_~".+N*}
_~

Provalo qui.

Mentre più corto, probabilmente un po 'meno interessante della soluzione Fission.

Spiegazione

{       e# Quine framework. Runs the block while another copy of it is on the stack.
  `     e# Stringify the block.
  "_~"  e# Push the remaining code as a string.
  .+    e# Element-wise append... essentially puts the two strings in a grid and 
        e# transposes it.
  N*    e# Join with linefeeds.
}_~

Fissione , 17 byte

Ancora la mia lingua preferita per i quines ...

'"
!0
0+
;!
DN
"!

Provalo online!

Spiegazione

Questo è abbastanza simile al quine di Fissione di base . In effetti, se non fosse stato per il "deve avere almeno due linee con almeno due caratteri non-ritorno a capo ogni" regola, ho semplicemente potuto trasposto tale e sostituire Rcon D. Questa regola rende le cose un po 'più interessanti, perché dobbiamo stampare un'altra riga.

Il flusso di controllo inizia dal Dcon un singolo atomo che va verso sud. Poiché colpisce ", si avvolgerà e stamperà

'!0;D

a STDOUT, simile a come sarebbe nel normale quine. '!quindi imposta la massa dell'atomo sul codice carattere di !. Il 0è un teletrasporto che trasporta l'atomo per la seconda colonna, dove è ancora in movimento a sud.

Con +incrementiamo la massa dell'atomo al valore di ". !N!le stampe citano, avanzamento riga, citazione. STDOUT ora appare così:

'!0;D"
"

Dopo essersi avvolto, l'atomo ne colpisce un altro "e ora stampa la seconda riga alla lettera:

'!0;D"
"0+!N!

Abbiamo finito adesso. L'atomo usa ancora il teletrasporto e atterra nel ;quale lo distrugge e quindi termina il programma.

Suppongo che il punto più pulito qui sia mettere uno "in basso e l'altro in alto in modo da poterli stampare in una volta senza dover impostare il valore di !una volta di più (perché verrebbe sovrascritto entrando di nuovo in modalità stringa).

Javascript ES6, 90 byte

$=_=>[...(_=`$=${$};$()`.split`
`)[0]].map((x,y)=>_.map(v=>[...
v][y]).join``).join`
`;$()

Non male non male.

Spiegazione

Ecco il framework quine standard:

$=_=>`$=${$};$()`;$()

Per modificare, ho semplicemente diviso la stringa di quine lungo newline e caratteri per creare una matrice di caratteri, trasposta utilizzando 2 funzioni della mappa e unita per creare l'output.

Stax , 23 byte

"34bL:f2MMm
"34bL:f2MMm

Provalo online!

Adattamento del "34bL"34bLquine, che si basa su un'idea utilizzata nelle quine in molte lingue.

Befunge-93 , 57 byte

^
_^
,@
+,
5*
52
,+
*9
28
+|
9
8#
|!
 ,
##
!:
,^
#
:
^
""

Funziona mettendo ogni personaggio nella prima colonna della pila (tranne la citazione stessa), quindi stampando ogni oggetto fuori dalla pila. Successivamente, stampa la citazione, stampa una nuova riga e quindi passa alla seconda colonna. Fa la stessa cosa senza stampare una nuova riga.

Puoi testarlo nel link nel titolo, ma dovrai copiare e incollare il codice nella finestra da solo. Se premi il pulsante "lento", ti mostrerà il percorso seguito dal puntatore e lo stack in quel momento.

Python 2, 91 75 69 byte

s='#%r;print"s#\\n="+"\\n".join(s%%s)';print"s#\n="+"\n".join(s%s)
##

Provalo online

Spiegazione:

Questo utilizza una modifica dello standard quine:

s='s=%r;print s%%s';print s%s

Dopo la modifica:

s='s=%r;print"\\n".join(s%%s)';print"\n".join(s%s)

Ciò sarebbe sufficiente se fosse consentita una sola riga. Quindi, ho aggiunto due caratteri alla seconda riga per soddisfare tale requisito. Il# caratteri sulla seconda riga possono essere sostituiti con qualsiasi cosa, purché vengano modificati anche nella prima riga, e rende il programma sintatticamente valido.

Per stamparlo correttamente ora, devo stampare #alla fine delle prime due righe. Quindi rimuovo i primi due caratteri dalla stringa se li stampa con #prima di stampare s%s. Ho messo uno dei #all'inizio di ssalvare alcuni byte rimuovendo letteralmente una nuova riga.