Quine / Revine Quine

26

Scrivi un programma completo che accetta un input intero booleano o non negativo. Deve:

  • Emette il proprio codice sorgente se il valore di input è errato
  • Emettere il proprio codice sorgente al contrario se il valore di input è true

Il tuo programma non può essere palindromico, né può leggere il proprio codice sorgente in alcun modo.

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

code-golf  quine 
— Luca
fonte
6
Quindi ... se la mia lingua non ha booleani. Ma 0 è falsa e numeri interi positivi sono veritieri. Posso supporre che l'input sarà solo 0 o 1 (come stand-in per i booleani - la lingua produrrà sempre uno di quei due come risultato di un operatore condizionale)? O devo supportare numeri interi, dal momento che non posso usare booleani "reali"?
— Martin Ender,

Risposte:

9

Gol> <> , 9 byte

'rd3*I?rH

Mi sento un po 'imbarazzante nel pubblicare questo, dal momento che abbiamo già> <>, Vitsy e Minkolang risposte. Le uniche aggiunte al quine standard sono I(leggi input intero), ?(esegui successivo se sinceramente) e r(inverso stack).

Provalo online .

— SP3000
fonte
Entra nel club! : D Stai vincendo comunque. +1
— Addison Crump
1
8 byte:sP#Hr?I"
— Jo King
18

CJam, 17 16 byte

{`"_~"+Wq~g#%}_~

Provalo qui.

Una modifica abbastanza semplice della quine standard. Altre soluzioni per 17 byte:

{`"_~"+q~{W%}&}_~
{`"_~"+q~!2*(%}_~

Se posso supporre che l'ingresso sia solo 0 o 1 (come stand-in per un valore booleano, per il quale non esiste un tipo dedicato in CJam), ottengo 15 omettendo il g:

{`"_~"+Wq~#%}_~

Spiegazione

{`"_~"+  e# Standard generalised quine framework. Leaves the source code on the stack. 
  W      e# Push a -1.
  q~     e# Read and evaluate input.
  g      e# signum, turning truthy values into 1 (leaving 0 unchanged).
  #      e# Power. -1^0 == 1, -1^1 == -1.
  %      e# Select every Nth element: a no-op for 1 and reverses the string for -1.
}_~
— Martin Ender
fonte
Dato che 0 e 1 sono i booleani di CJam, non penso che tu abbia bisogno di g.
— Dennis,
@Dennis Sì, non ne ero davvero sicuro.
— Martin Ender,
Sorprendentemente, in qualche modo ho battuto questo. oo Non mi sorprenderò se lo golf più giù però. : D
— Addison Crump,
9

Pyth, 17 byte

_WQjN*2]"_WQjN*2]

Una semplice modifica dello standard Pyth quine.

— isaacg
fonte
Accidenti, stavo aspettando di postare questo da un'ora dopo che era stato sandbox.
— lirtosiast,
7

> <>, 17 byte

Richiede il flag -v (+1 byte) per inserire l'input nello stack (o per inserire in anticipo l'input nello stack nell'interprete online).

'rd3*$?rol?!;70.

Potresti fare quanto segue per lo stesso numero di byte (senza il flag) se solo gli input interi fossero consentiti (ovvero 0 per falsy, 1 per verità).

'rd3*ic%?rol?!;80.

Provalo online

Verità / falsa per> <> sono qualcosa non rispettivamente 0 e 0.

— ravizzone
fonte
6

Vitsy , 15 byte

... Sto ... sto battendo CJam! (grida) Mamma! Guarda, mamma, l'ho fatto!

'RD3 * I86 * -) rl \ O

Spiegazione:

'RD3 * I86 * - (RL \ O
Quine standard, ma con una svolta:

'Cattura il codice sorgente come una stringa
 rd3 * Crea il carattere in ASCII
     i86 *: ottieni il carattere di input come ASCII, quindi sottrai 48 da esso. 
                    Se è zero, l'istruzione if salterà l'istruzione successiva.
          (r Se l'articolo in cima alla pila è zero, non eseguire l'elemento successivo.
                    L'elemento successivo qui è al contrario.
            Stampa la risma.

Versione più recente di Vitsy , 11 byte

v'rd3 *} v) rZ
v Cattura l'input come variabile.
 'Cattura la fonte fino a quando non ne incontri un'altra'
  r Invertire la pila.
   d3 * Premi "verso lo stack.
      } Ruota la pila verso quella giusta.
       v) Spingere la variabile (input) nello stack e verificare se non è zero.
         r In tal caso, invertire la pila.
          Z Stampa tutto nello stack.
— Addison Crump
fonte
2

Javascript (ES6), 42 byte

$=_=>'$='+(_?$:[...''+$].reverse().join``)

Questa è una modifica del mio Bling Quine . È anche il doppio.

— Mama Fun Roll
fonte
Questo ha effettivamente prodotto qualcosa? Le risposte che funzionano solo in una REPL non sono consentite.
— feersum
1
@ETHproductions Che chiamerebbe la funzione, ma non stampa nulla. Inoltre, non sarebbe più un quine.
— Dennis,
@Dennis Giusto. Bene, suppongo che questo prompt()sia necessario, a meno che non passiamo a Node.JS. Credo che $=_=>(A=`$=${$};$(prompt())`,alert(_?A:[...A].reverse().join``));$(prompt())funzioni correttamente, anche se forse si potrebbe giocare di più.
— ETHproductions
1
"Il tuo programma non può [...] leggere il proprio codice sorgente in alcun modo." Questa soluzione rientra in questa categoria?
— ETHproductions
2

Burlesque, 40 byte

ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

Spiegazione:

Burlesque dispone di funzionalità avanzate di manipolazione dello stack e del codice. In effetti, non è possibile accedere al codice sorgente del programma ma è possibile accedere al codice rimanente che deve essere eseguito in futuro. Ciò significa #Qche restituirà tutto il codice che lo segue, motivo per cui dobbiamo aggiungere tutto #Qa quel codice che è quello che stiamo facendo ri#Q.

blsq ) #Q1 2++
12 -- this is the result of 1 2++
{1 2 ++} -- this is the result of #Q

++1 2è un codice tecnicamente illegale poiché è basato su stack. Ma possiamo manipolare il codice per farlo eseguire come 1 2++:

blsq ) #Q<-#q++1 2 
12

Lavorare con questi built-in è incredibilmente complicato e nessuno li ha ancora usati per qualcosa di produttivo, tranne per le cose relative. Se si inverte ++1 2ottieni 2 1++ciò che produrrebbe 21e non 12. Il motivo per cui il codice sopra riportato 12è perché #Qinclude anche il <-così alla fine eseguiamo molto di più di un semplice 2 1++: p. Finiamo per eseguire ciò 2 1++#q<-che produce 12.

Possiamo effettivamente sostituire cose nel nostro codice, ad esempio questo codice sostituisce tutte le occorrenze di ?+per sé con?*

blsq ) #Q(?+)(?*)r~5.-#q5 5?+
25

Uso:

$ echo "1" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
hs fi sp "-<" j +. /\ "Q#ir" -~ HS 2Q#ir
$ echo "0" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh
— mroman
fonte
2

Haskell, 126 118 108 byte

main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="

Prevede 0o 1come input.

— Nome del modello
fonte
2

Minkolang 0,10 , 13 byte

"66*2-n,?r$O.

Provalo qui.

Questo è esattamente come la Quine standard, tranne per questi quattro personaggi: n,?r. nprende un numero intero dall'input, lo ,inverte, quindi ?salta rse l'input è veritiero. Altrimenti, rinverte lo stack in modo che venga emesso in ordine inverso.

— El'endia Starman
fonte
1
Il mio tuono è sparito. : c
— Addison Crump,
2

Python 2, 51 byte

s="print('s=%r;exec s'%s)[::1-2*0**input()]";exec s
— SP3000
fonte
0

Java 10 (programma completo), 282 byte

interface N{static void main(String[]a){var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}

Provalo online.

Java 10 (come funzione lambda), 154 byte

b->{var s="b->{var s=%c%s%1$c;s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}";s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}

Provalo online.

Spiegazione:

interface N{                          // Class
  static void main(String[]a){        //  Mandatory main-method
    var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";
                                      //   Unformatted source code
    s=s.format(s,34,s);               //   Format the source code (the quine-String)
    System.out.print(                 //   Print:
      new Boolean(a[0])?              //    If the input is true:
       new StringBuffer(s).reverse()  //     Print the quine-String reversed
      :                               //    Else:
       s);}}                          //     Print the quine-String as is

quine spiegazione:

  • Il var scontiene il codice sorgente non formattato
  • %s è usato per mettere questa stringa in sé con s.format(...)
  • %c, %1$ce 34vengono utilizzati per formattare le virgolette doppie
  • s.format(s,34,s) mette tutto insieme

E quindi new StringBuffer(s).reverse()viene utilizzato per invertire la stringa quine, se necessario, in base all'input-booleano.

— Kevin Cruijssen
fonte
0

05AB1E , 21 byte

0"D34çý‚sè"D34çý‚sè

Provalo online.

Modifica del quine predefinito 0"D34çý"D34çýaggiungendo ‚sè.

Spiegazione:

0                        # Push 0 to the stack
                         #  STACK: [0]
 "D34çý‚sè"             # Push the string 'D34çý‚sè' to the stack
                         #  STACK: [0, 'D34çý‚sè']
            D            # Duplicate this string
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè']
             34ç         # Push '"' to the stack
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè', '"']
                ý        # Join the stack with '"' delimiter
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè']
                 Â       # Bifurcate (short for Duplicate & Reverse)
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè', 'ès‚Âýç43D"ès‚Âýç43D"0']
                  ‚      # Pair them up:
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0']]
                   s     # Swap to get the boolean input (0 or 1)
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0'], 1]
                    è    # Index the input into the list
                         #  STACK: ['ès‚Âýç43D"ès‚Âýç43D"0']
                         # (Output the top of the stack implicitly)

PS: stampa automaticamente una nuova riga finale. Se anche questo dovesse essere invertito, è invece di 23 byte:

0"D34çý‚sè?"D34çý‚sè?

Provalo online. ( ?è una stampa esplicita senza nuova riga )

— Kevin Cruijssen
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.