Invertisco il codice sorgente, si annulla l'input!

36

Sfacciata palese di una fregatura . Votare quelli!

Il tuo compito, se desideri accettarlo, è scrivere un programma / funzione che emetta / restituisca il suo input / argomento intero. La parte difficile è che se invertisco il codice sorgente, l'output deve essere l'intero intero negato.

Esempi

Diciamo che il tuo codice sorgente è ABCe il suo input è 4. Se CBAinvece scrivo ed eseguo, l'output deve essere -4.

Diciamo che il tuo codice sorgente è ABCe il suo input è -2. Se CBAinvece scrivo ed eseguo, l'output deve essere 2.

Un input di 0può dare 0o -0, tuttavia, se si supporta lo zero firmato, -0dovrebbe dare 0.

code-golf  math  number  source-layout 
— Adamo
fonte
5
Perché abbiamo bisogno di una copia della stessa domanda?
— Christian,
5
@Christian Quello che genera un numero costante (e la sua negazione) mentre questo deve prendere input e restituirlo / negarlo. Un lavoro molto diverso in molte lingue.
— Adám,
5
A sì, ora vedo la differenza. Bisogna leggere MOLTO attentamente
— Christian
Se usi un linguaggio strutturato come C #, stai semplicemente invertendo le righe?
— PerpetualJ,
@PerpetualJ No, guarda l'origine come un elenco di caratteri, alcuni dei quali sono interruzioni di riga.
— Adám,

Risposte:

11

codice macchina x86, 3 byte

C3 D8 F7

I suddetti byte di codice definiscono una funzione no-op: restituisce semplicemente il controllo al chiamante. Questa funzione è seguita da due byte di immondizia che non verranno eseguiti, poiché arrivano dopo un ritorno: si trovano nella "terra di nessuno". In assemblatore mnemonico:

ret                     ; C3    
fdiv  st(0), st(7)      ; D8 F7

Bene, quindi ora arriva un troll che inverte l'ordine dei byte:

F7 D8 C3

Questi byte ora definiscono una funzione che accetta un argomento intero nel EAXregistro, lo annulla e restituisce il controllo al chiamante. In assemblatore mnemonico:

neg  eax     ; F7 D8
ret          ; C3

Quindi ... è stato semplice. :-)

Si noti che possiamo fare in modo che l'istruzione "negazione" sia tutto ciò che vogliamo, poiché non viene mai eseguita nell'orientamento "in avanti" e eseguita solo nell'orientamento "invertito". Pertanto, possiamo seguire lo stesso schema per fare cose arbitrariamente più complicate. Ad esempio, qui prendiamo un argomento intero in un registro diverso (diciamo, EDIper seguire la convenzione di chiamata System V comunemente usata sui sistemi * nix), lo neghiamo e lo restituiamo nel EAXregistro convenzionale :

C3      ret
D8 F7   fdiv  st(0), st(7)      ;  \ garbage bytes that
F8      clc                     ;  | never get executed,
89      .byte 0x89              ;  / so nobody cares

  ↓ ↓

89 F8   mov  eax, edi
F7 D8   neg  eax
C3      ret
— Cody Grey
fonte
7

Haskell , 8 byte

Funzione di identità anonima, che si trasforma in sottrazione da 0quando invertita.

id--)-0(

Provalo online!

invertito:

(0-)--di

Provalo online!

— Ørjan Johansen
fonte
2
Sei riuscito a rompere l'evidenziazione del codice con la tua versione invertita!
— Tim
@Tim Curious. I test suggeriscono che fallisce quando un commento inizia subito dopo una parentesi giusta.
— Ørjan Johansen,
6

Spazio bianco , 48 byte

S S S N
S N
S T N
T   T   T   T   T   T   N
S T N
N
N
T   S N
T   N
S S T   N
T   T   S S T   T   T   T   T   N
T   S N
S N
S S S

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.

Modifiche minori della mia risposta agli spazi bianchi per invertire il codice sorgente, si annulla l'output! sfida .

Provalo online o provalo online invertito (solo con spazi grezzi, schede e nuove righe).

Spiegazione:

Utilizzando il programma di uscita incorporato essendo un palindromo breve NNN.
Il programma regolare dovrà:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Il programma inverso:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
SSTTN  # Push -1 to the stack
TSSN   # Multiply the top two values on the stack together
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Piccola spiegazione aggiuntiva di come spingere un numero:

  • Primo S: abilitare la manipolazione dello stack
  • Secondo S: spingere un numero nello stack
  • Soppure T: rispettivamente positivo / negativo
  • Alcuni S/ Tseguiti da un trascinamento N: numero in binario, dove S=0eT=1

Cioè SSTTSTSNspinge -10. Per 0noi non abbiamo bisogno di un esplicito S=0, quindi semplicemente SSSNo SSTNè abbastanza.

— Kevin Cruijssen
fonte
5

Perl 6 / Raku, 3 byte

*-0

Provalo online!

Crea un blocco di codice Qualunque. Leggi normalmente il suo equivalente di blocco standard è -> \x {x - 0}, ma al contrario diventa -> \x {0 - x}.

— user0721090601
fonte
5

Brain-Flak , 7 byte

#)]}{[(

Provalo online!

invertito:

([{}])#

Provalo online!

Nota: funziona solo con interpreti che supportano i commenti (ad esempio funziona in Rain-Flak, ma non in BrainHack)

Se scambiamo anche parentesi aperte / chiuse anziché semplicemente invertire i byte, possiamo farlo in 8 byte senza usare i commenti:

({}[{}])

Provalo online!
Provalo al contrario!

— Riley
fonte
Questo abuso di comportamento non definito? Non credo che le specifiche Brain-Flak consentano tale parentesi.
— Altamente radioattivo il
@TwilightSparkle #Inizia un commento, quindi le parentesi nella versione originale vengono ignorate.
— Riley,
Oh sì, ho dimenticato! Ma funziona solo in Rain-Flak allora (è comunque l'interprete ufficiale). Probabilmente dovrai menzionarlo?
— Altamente radioattivo
@TwilightSparkle ha aggiunto una nota per chiarimenti. Grazie.
— Riley,
Piccola sfida divertente: puoi farlo senza commenti se cambi anche le parentesi di apertura / chiusura invece di semplicemente invertire?
— DJMcMayhem
4

MarioLANG , 22 byte

;:
=#
:)!
--
<(
"
[>
;

Provalo online!

Inserisce e genera il numero prima di cadere in EOF

invertito:

;
>[
"
(<
--
!):
#=
:;

Provalo online!

Fa un ciclo fino a quando il valore di input è 0 e il valore di output è -input, quindi dice il numero.

— Dorian
fonte
4

R , 23 byte

Ho deciso di provarlo senza il trucco dei commenti.

Inoltrare

`+`=scan;""+-0;nacs=`+`

Provalo online!

Inverso

`+`=scan;0-+"";nacs=`+`

Provalo online!

Nella versione successiva +agisce un operatore binario ed -è un operatore unario.

Al contrario, +diventa unario e -binario. Quindi la funzione scan accetta gli argomenti: file=""che significa stdin e what=0, che sono anche valori predefiniti. Quindi quando il+ è unario il primo argomento è a destra, quando è binario il primo argomento è a sinistra.

Il 

;nacs=`+`

parte del codice non fa nulla di veramente utile, quindi in un certo senso il mio codice non è molto più valido dell'uso del trucco dei commenti.

— Aaron Hayman
fonte
1
Questo è molto intelligente (+1). Spesso ridefiniamo gli operatori R in byte di golf, ma penso che questa sia la prima volta che ho visto +ridefinito per essere usato sia come unario che binario. Mi ci è voluto un minuto per capire come è stato analizzato ... Nessun altro nome dell'operatore avrebbe fatto il lavoro.
— Robin Ryder,
4

Perl 5 ( -p), 7 6 byte

-1 grazie a @primo

$_*=$#

TIO

Un commento non cambia l'input

#1-=*_$

Annulla l'input

$_*=-1#

TIO

— Nahuel Fouilleul
fonte
-1: $_*=$# TIO . Si noti che #deve essere l'ultimo byte del programma, altrimenti verrà interpretato come variabile $#, anziché come l'ultimo indice dell'array con il nome <empty>.
— primo
1
tuttavia non capisco come funziona perché provare a stampare $#dà un errore (se # non è l'ultimo carattere) o niente
— Nahuel Fouilleul,
Sembra funzionare solo con -po -n. Sospetto che la piastra della caldaia abbia qualcosa a che fare con questo ...
— primo
2
@primo Funziona perché -p/-naggiunge un ;dopo il codice. Ciò significa che in $#realtà è $#;: la dimensione dell'array @;. Se la dimensione delle @;modifiche, il risultato non è più corretto ( TIO ). Comunque, questo è super intelligente, ben fatto! :)
— Dada,
questa è la spiegazione che si potrebbe vedere con perl -MO=Deparse -p <(echo -n '$_*=$#'), perché sembra perl -MO=Deparse -pe '$_*=$#'aggiungere una nuova riga
— Nahuel Fouilleul,
4

Gaia , 2 byte

_@

Provalo online!

_	| implicit push input and negate
 @	| push next input OR push last input (when all inputs have been pushed)
	| implicit print TOS

invertito:

@	| push input
 _	| negate
	| implicit print TOS
— Giuseppe
fonte
4

Rovescio , 6 5 byte

I@-Ov

Provalo online! Provalo raddoppiato!

Reso un po 'complesso a causa della natura del puntatore in Rovescio. Non penso che sia possibile ottenere un haha più corto , risulta che mi sbagliavo. Ciò non duplica alcuna istruzione e riutilizza sia i comandi di input, output sia di terminazione tra i due programmi. Ora penso che sia ottimale, dal momento che hai bisogno di tutti i IO-@comandi per funzionare, e in un programma a 4 byte puoi eseguire solo due di quei comandi.

Spiegazione:

Il puntatore in Rovescio si sposta su tre celle un segno di spunta e rimbalza sui confini della cella, il che significa che la logica generale si sovrappone. Tuttavia è possibile manipolare questa velocità con ve^ comandi .

Il programma originale esegue le istruzioni IO-@, che viene immesso come numero, emesso come numero, sottratto, termina. Ovviamente la sottrazione è superflua. Nel codice questi sono:

I@-Ov
^  ^    Reflect
  ^     Reflect again
 ^

Viene eseguito il programma invertito v-I-vO-@. L' vriduce i passaggi puntatore tra zecche, e -sottrae dal fondo della pila, che è implicitamente zero. I -comandi extra non fanno nulla. Il programma viene eseguito come

vO-@I
v       Reduce pointer speed to 2
  -     Subtract zero from zero
    I   Get input as number and reflect off boundary
  -     Subtract input from zero
v       Reduce pointer speed to 1
 O      Output as number
  -     Subtract zero from zero
   @    Terminate
— Jo King
fonte
3

R , 14 byte

scan()#)(nacs-

Provalo online!

Un programma completo che legge un numero o legge e annulla un numero. La funzionalità inversa è protetta da un commento in linea

— Nick Kennedy
fonte
Le parentesi sono nella direzione sbagliata nella parte commentata.
— Aaron Hayman,
@AaronHayman grazie!
— Nick Kennedy,
3

Python 3 , 22 14 byte

int#__bus__. 0

Provalo online!

Utilizza il intcostruttore della classe e un metodo pseudo-privato incorporato.

— mypetlion
fonte
Huh. Perché lo spazio prima dell'attributo è obbligatorio?
— Jo King,
2
@JoKing 0.verrebbe interpretato come un numero, seguito da un simbolo
— attinat
2

APL (Dyalog Unicode) , 13 3 byte

-∘0

Provalo online!

Risposta fondamentale. Restituisce argo¯arg .

Salvato 10 byte non essendo stupido (grazie Adám).

Modificato il 3-byte risultante in una funzione più adatta.

— J. Sallé
fonte
Whoa, questo può essere fatto in modo banale in tre byte!
— Adám,
È interessante notare che hai già una risposta a 3 byte incorporata come sottostringa di questo.
— Adám,
@Adám sì, sapevo che da qualche parte c'era una risposta semplice. Grazie.
— J. Sallé,
2

Linguaggio di Turing Machine , 39 byte

Il positivo

1 r - _ 0
0 l * * 0
0 - _ l 0
0 _ _ r 0

Il negativo

0 r _ _ 0
0 l _ - 0
0 * * l 0
0 _ - r 1

Questo è stato un po 'più complicato di quanto pensassi, soprattutto perché ho dovuto superare i miei pregiudizi di avere codice che corre con errori di "compilazione".

— ouflak
fonte
2

> <> , 5 4 byte

n-r0

usa l'inizializzazione dello stack con l' -vopzione, inserisci la variabile di input lì.

Provalo online!

Oppure prova l'inversione

Spiegazione

n       Prints whatever is on the stack as a number
 -      Subtract the top 2 elements on the stack.
        There aren't 2 elements, so it crashes.
  r0    Never gets executed

or reversed:

0       Push a 0 onto the stack
 r      reverse the stack (now 0, -v)
  -     Subtract top 2 elements and push result (0-v, ie negated)
   n    Print as number
        The code wraps around and executes again. 
        It crashes on the - as there is only one
        item on the stack: 0.
— steenbergh
fonte
2

Stack Cats -mn , 2 byte

-X

Provalo online!

Prova il contrario!

Spiegazione

Si scopre che questo è in realtà molto più semplice della precedente sfida in Stack Cats. Il programma completo (dopo l'applicazione -m) qui è -X-. Xviene utilizzato per scambiare le pile a sinistra e a destra della testina del nastro, ovvero non influisce affatto sullo stack iniziale, quindi possiamo ignorarlo. Ma poi il programma è effettivamente giusto-- (negare due volte la parte superiore dello stack), il che non fa nulla.

Per il programma inverso, l'applicazione -mdà X-X. Ancora una volta, Xnon fa nulla, quindi il programma è effettivamente giusto -, il che nega la cima dello stack.

L'unica altra soluzione a 2 byte è -=, ma è praticamente la stessa. L'unica differenza è che =scambia solo le cime delle pile adiacenti, non le pile intere.

Ma ancora una volta, usare -mè un po 'come imbrogliare, quindi di seguito è una soluzione che utilizza un programma completamente mirror.

Stack Cats -n , 7 byte

:I<->I:

Provalo online!

Prova il contrario!

Spiegazione

Le considerazioni della risposta precedente si applicano ancora : qualsiasi soluzione valida deve utilizzare i caratteri associati e I. Le sei possibili soluzioni (incluse nel collegamento TIO) sono praticamente tutte uguali. -e _sono equivalenti in questo programma e :possono essere sostituiti da |o T(che fanno lo stesso per input diversi da zero e coincidono anche per input zero). Ho appena scelto questo per spiegare perché è più semplice.

Quindi ricorda che lo stack iniziale contiene l'input sopra a -1(sopra infinitamente molti zeri) mentre tutti gli altri stack lungo il nastro contengono solo zeri. Stack Cats ha anche la proprietà che qualsiasi programma di lunghezza pari non fa nulla (a condizione che termini, ma non possiamo comunque usare loop per questa sfida). Lo stesso vale ovviamente per qualsiasi programma di lunghezza dispari il cui personaggio centrale non fa nulla ... vediamo:

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
<    Move another stack left (without taking the value).
-    Negate the zero on top of that stack (i.e. do nothing).

Pertanto, la seconda metà del programma annulla esattamente la prima metà e finiamo con l'input in cima a di -1nuovo.

Il programma inverso è :I>-<I:. Vediamo come questo cambia le cose:

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
>    Move one stack right, i.e. back onto the initial stack which still holds the input.
-    Negate the input.
<    Move back to the left where we've parked the 1.
I    Move that 1 back onto the initial stack and turn it back into a -1.
:    Swap the -1 below the negated input to act as an EOF marker.
— Martin Ender
fonte
2

Lotto, 34 byte

@ECHO.%1 2>MER@
@REM>2 1%=-aa/TES@

Fa eco ( ECHO.) all'input ( %1). Il resto della prima riga reindirizza tecnicamente STDERRa un file chiamato MER@, ma questo non ha impatto.
La seconda riga è commentata ( REM...).

Reversed

@SET/aa-=%1 2>MER@
@REM>2 1%.OHCE@

Utilizza la modalità aritmetica del comando set ( SET /a) per sottrarre ( -=) l'input ( %1) da una variabile non definita ( a) che è equivalente a 0 - input. Ancora una volta, il resto della prima riga reindirizza tecnicamente STDERRa un file chiamato MER@, ma questo non ha impatto.
La seconda riga è commentata ( REM...).

— Οurous
fonte
Questo sembra interessante. Ti interessa spiegare?
— Adám,
@Adám Aggiunta una spiegazione e realizzato anche che avevo i programmi all'indietro.
— Οuroso
2

Brachylog , 2 byte

&ṅ

Brachylog implicitamente input da sinistra e output da destra.
&ignora qualsiasi cosa a sinistra e passa l'ingresso alla funzione verso destra.
ṅvincola ciascun lato ad essere versioni negate l'una dell'altra.

Provalo online

— IFcoltransG
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.