Esegue le stampe all'indietro


102

Il tuo compito è di invertire l'ordine in cui alcuni printsvengono eseguiti.


Specifiche: il
tuo codice sarà in questa forma:

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

Dovrai print(o echo, o write, o equivalente) quelle stringhe dalla quarta alla prima.

  • Decidi quali linee del tuo programma devono essere printle stringhe, ma devono essere adiacenti ;

  • Ogni riga può contenere solo uno printe non può superare i 60 byte di lunghezza;

  • Dato che si tratta , sii creativo ed evita di scrivere solo una gotoo una semplicefor(i){if(i=4)print"Line1";if(i=3)...}

  • La risposta più votata in 2 settimane vince questa.

  • L'output DEVE essere Line4 Line3 Line2 Line1 OR Line4Line3Line2Line1 OR Line4\nLine3\nLine2\nLine1 (dove \nè una nuova riga) e deve essere generato solo eseguendo quelli printsall'indietro.

Buona programmazione!

AGGIORNAMENTO: il concorso è finito! Grazie a tutti :)


15
Conta l'arabo? :)

Se sei in grado di soddisfare le specifiche, ovviamente: P
Vereos,

Volevo chiarire rapidamente una regola ... Quando dici "Ogni like può contenere solo una stampa", intendi una riga di testo nel file di codice o un'istruzione LOC /?
Ruslan,

Ogni riga di codice può contenere solo una stampa
Vereos,

deve passare una revisione del codice - adatto per il codice di produzione?
Lancia,

Risposte:


183

Commodore 64 BASIC

40 print "Line 1"
30 print "Line 2"
20 print "Line 3"
10 print "Line 4"

83
Non sono mai riuscito a capire perché siano necessari i numeri di riga, fino ad ora.
ugoren,

3
Stavo per proporre, copiando Character ROM ($ D000) in RAM ($ 3000), scambiando bitmap di caratteri per "1" <-> "4" e "2" <-> "3", quindi eseguendo il programma in ordine avanti . Questo è più carino.
Mark Lakata,

Sono abbastanza sicuro che non puoi effettivamente salvare / caricare o altrimenti elencare il codice nell'ordine mostrato usando gli strumenti standard (sicuramente non è possibile su Apple II comunque), tutto ciò che potresti fare sarebbe digitare quelle righe nella console in questo ordine. E se ciò è permesso, non potresti semplicemente usare, ad esempio, la libreria SendKeys di C # per digitare il codice in una qualsiasi delle lingue risposte in un ordine diverso con i tasti freccia per spostarti.
Lancia,

109

PHP

Precedenti abusanti ... :-)

!print "Line1\n".
!print "Line2\n".
!print "Line3\n".
!print "Line4\n";

3
In PHP, printpuò essere usato come espressione, come può essere in perl, il cui valore di ritorno è sempre 1. !1restituisce bool(false), che quando viene digitato come stringa restituisce la stringa vuota. Una restrizione più adeguata per PHP potrebbe essere quella di richiedere echopiuttosto che print; quanto sopra è davvero solo un'affermazione.
primo

1
@ kuldeep.kamboj È semplicemente raggruppato in questo modo: print ("Line 1". !print ("Line2". !print ("Line 3". !print "Line4")));- tutto ciò che si trova sulla destra di una dichiarazione stampata ne fa parte.
bwoebi,

4
Sembra funzionare in ogni versione 3v4l.org/dpSpK molto impressionante!
eisberg,

3
Mi ci è voluto un po 'per capire (Grazie @eisberg per il link!) Ma ora capisco. Mentre il primo printviene chiamato per primo, non termina di evacuare ciò di cui ha bisogno per stampare fino a quando gli interni (inferiori) printsono già stati chiamati e completamente valutati. E gli !s sono solo per nascondere gli 1 che altrimenti verrebbero stampati. Fantastico, @bwoebi!
sfarbota,

1
@sfarbota La lettura delle regole è difficile. Fisso. Grazie :-)
bwoebi,

76

C

Il comportamento indefinito è il tipo di comportamento più eccitante!

f(){}
main()
{
   f(printf("Line 1\n"), 
     printf("Line 2\n"), 
     printf("Line 3\n"), 
     printf("Line 4\n"));
}

L'output effettivo può variare in base al compilatore, al linker, al sistema operativo e al processore :)


22
Non ho assolutamente idea di come mai questo funzioni effettivamente, +1.
svick,

7
@svick: per supportare varargs, la maggior parte dei compilatori C mette gli argomenti delle funzioni sullo stack in ordine inverso (quindi l'elemento in cima allo stack è sempre il 1 ° argomento), il che significa che è probabile che valutino gli argomenti allo stesso modo. Naturalmente, ciò presuppone che gli argomenti vengano passati sullo stack, che diventa sempre meno il caso dei compilatori più recenti.
Guntram Blohm,

Come ha detto @GuntramBlohm, l'idea di base è che i parametri della funzione C vengono spesso (ma non sempre) inseriti nello stack in un ordine da destra a sinistra. Poiché si tratta di chiamate di funzioni, le funzioni sono probabilmente (ma non necessariamente) chiamate anche da destra a sinistra. Tuttavia, tutto ciò non è definito dallo standard C, quindi mentre dà il risultato giusto in GCC 4 dipende totalmente dal compilatore e dalla convenzione di chiamata cosa succede realmente.
Nick,

1
@fluffy: Ahimè, è il contrario: C non considera le virgole arglist come punti di sequenza, a differenza di altre virgole.
Williham Totland,

6
@WillihamTotland, allora conosco del codice che devo davvero risolvere ... grazie
soffice

74

Giava

Usando la riflessione

public class ReversePrint {
    public static void main(String[]a) {
        System.out.println("Line1");
        System.out.println("Line2");
        System.out.println("Line3");
        System.out.println("Line4");
    }
    static {
        try{
            Field f=String.class.getDeclaredField("value");
            f.setAccessible(true);
            f.set("Line1","Line4".toCharArray());
            f.set("Line2","Line3".toCharArray());
            f.set("Line3","Line2 ".trim().toCharArray());
            f.set("Line4","Line1 ".trim().toCharArray());
        }catch(Exception e){}
    }
}

Produzione:

Line4
Line3
Line2
Line1

Una spiegazione del perché questo funziona può essere trovata qui .


61
Orribile. Mi piace.
Roger Lindsjö,

4
+1 Le persone dicono sempre che le stringhe Java sono immutabili. Dimostrate che non lo sono.
Victor Stafusa,

16
Questo è deliziosamente brutto, ma il requisito dell'esecuzione inversa non è soddisfatto.
Thorbjørn Ravn Andersen,

4
@ ThorbjørnRavnAndersen shhhh ... non dovresti dirglielo. : p
Danny,

5
@Victor In Java, le stringhe sono immutabili. In tutto Stackoverflow, ci sono domande come "Pensavo che le stringhe fossero immutabili". Usano la riflessione e li fa sembrare immutabili. Le promesse di Java funzionano in questo modo: "Se usi le nostre cose / classi nel modo che intendiamo, promettiamo che le nostre affermazioni sono corrette." La riflessione non è il modo in cui le classi devono usare.
Giustino,

70

C (e specie di Python)

Nuova versione, utilizzando una macro per adattarsi perfettamente al formato della domanda. Dopo il commento di Quincunx, l'ho aggiunto returnper renderlo più gradevole.

Funziona anche in Python, ma stampa nell'ordine corretto.

#define print"\n",printf(
#define return"\n"))));}
#define def main(){0?

def main():
    print "Line 1"
    print "Line 2"
    print "Line 3"
    print "Line 4"
    return

main();

Versione originale: i due sono praticamente gli stessi, dopo la sostituzione delle macro:

main(){
    printf("Line 1\n",
    printf("Line 2\n",
    printf("Line 3\n",
    printf("Line 4\n",
    0))));
}

1
+1 per la macro. Forse includerne un altro; qualcosa del tipo #define } 0))));(non so esattamente come funzionano le macro in C). In questo modo potresti semplicemente avere le istruzioni di stampa nel metodo principale, nient'altro.
Giustino,

@Quincunx, non puoi definire }, ma puoi definire return, cosa che ho fatto ora. Ora è quasi un poliglotta: la printsintassi funziona in diversi linguaggi di script, #defineè spesso un commento, ma main(){..}non funziona in nessuna lingua che potrei trovare.
ugoren,

1
@Quincunx, e ora è davvero un poliglotta.
ugoren,

in che modo i primi due definiscono il lavoro senza spazi? Farebbe printper essere sostituito da "\n",printf(?
phuclv,

@ LưuVĩnhPhúc - Lo spazio è facoltativo. Sostituisce come dici tu.
ugoren,

61

ES6 (utilizzando la modalità indietro;)

Wow, sembra che i progettisti di ECMAScript abbiano avuto un'incredibile lungimiranza quando hanno fatto parte della modalità all'indietro delle specifiche:

// activate backwards mode:
'use backwardsˈ; \* mode backwards in now *\
code of lines some \
\*code*\ "Line1" print \*code*\
\*code*\ "Line2" print \*code*\
\*code*\ "Line3" print \*code*\
\*code*\ "Line4" print \*code*\
code of lines some \
⁏ˈforwards useˈ // back to ˈnormal'.

// So simple! No need to do anything this complicated:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

Output (valutazione, davvero):

"Line4Line3Line2Line1"

Si noti che è esattamente del modulo richiesto, con solo una leggera backwardification per adattarsi alla sintassi della modalità . Nota anche che questa modalità è attualmente supportata solo nelle versioni recenti di Firefox .

Nota finale: in realtà, non esiste una modalità indietro. Ma questo è ancora uno script valido che viene eseguito in Firefox (copia tutto). : D


ES6 "modalità lassista"

BONUS : Ecco una versione aggiornata che non utilizza la modalità all'indietro, ma utilizza la "modalità lassista" appena specificata in cui il motore JS tenterà semplicemente di indovinare cosa dovrebbe fare il codice, indipendentemente dall'adesione a qualsiasi sintassi JS specificata ( fondamentalmente l'antitesi della modalità rigorosa):

// activate "lax" mode:
`use laxˋ; // also works: ˋuse relaxˋ, ˋuse guessingˋ, ˋuse whatevsˋ, etc.
//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code
ˋuse normalˋ; // same as ˋuse default`.

// Again, compare to inferior, illegible "traditional" ES6:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

Si noti che la " modalità lassista " è attualmente disponibile solo in Firefox> = 34.; P


7
Tutti e 3 i link che hai pubblicato portano a 404. È questo tipo di scherzo?
arte

8
Ah. Ora vedo. L'evidenziatore della sintassi è stato il tuo complice qui.
arte

12
Questo è un concorso combinato di popolarità e code-trolling , no? :) Lo adoro.
Non che Charles,

8
Questo è un abuso fenomenale di Javascript. Mi piace.
Seiyria,

2
Subdolo. Davvero subdolo ....
David Conrad,

59

C

main()
{
  int i = 0;
  for(; i == 0; printf("Line 1\n"))
    for(; i == 0; printf("Line 2\n"))
      for(; i == 0; printf("Line 3\n"))
        for(; i == 0; printf("Line 4\n"))
          i = 1;
}

56

Rubino

print 'Line1' unless
print 'Line2' unless
print 'Line3' unless
print 'Line4'

Modifica: in alternativa,

def method_missing(meth,*)
  puts meth.to_s.sub('print'){}
end

printLine1(
printLine2(
printLine3(
printLine4)))

38
Preferisco questo perché ha meth
Ray

2
Normalmente non pubblicheresti due risposte se avessi due soluzioni?
Costruttore

3
Non sembrerebbe più ruby-ish con i blocchi di codice? pastebin.com/LDWpxKx8
arte

2
@PacMani quei genitori non usano lo spazio bianco, usano lo spazio bianco.
corsiKa,

@manatwork nice one! Penso che method_missingsia piuttosto il rubino stesso, però.
istocrato,

49

PHP

Lo so, questa è follia ...

goto d;
a: print "Line1\n"; goto end;
b: print "Line2\n"; goto a;
c: print "Line3\n"; goto b;
d: print "Line4\n"; goto c;
end: exit;

66
Quel rumore che senti è Dijkstra che gira nella sua tomba. :-)
Gareth,

24
Pensavo che qualcuno goto
avesse

22
@TheConstructor La parte creativa sta usando goto in PHP ;)
NikiC,

1
Così pieno di vittorie.
Nick T,

41

Haskell

Questo è quasi idiomatico di Haskell, poiché il programma ora sembra una composizione di funzioni da destra a sinistra. Se la funzione non fosse stampata, ma qualcosa che restituirebbe un valore (utile), la dichiarazione dell'operatore non sarebbe necessaria e il codice sarebbe qualcosa che vedresti nelle librerie.

a << b = (const a =<< b)

main = putStrLn "Line1"
    << putStrLn "Line2"
    << putStrLn "Line3"
    << putStrLn "Line4"

5
consiglio:(<<) = flip (>>)
Bergi,

@Bergi Questo è un altro modo di scriverlo, immagino anche un po 'più elegante. In realtà sono stato un po 'sorpreso di vedere che la cosa non era definita nel preludio (o Control.Monad)
shiona,

@shiona: Sì, è una cosa sorprendente da perdere. Fortunatamente, abbiamo entrambi gli operatori per i candidati: <*e *>.
Tikhon Jelvis,

@TikhonJelvis in realtà, l' <*operatore applicativo è diverso da questo <<: a <* bequivale a do x<-a;b;return x, vale a dire che esegue aprima l'effetto
orgoglioso haskeller il

40

Perl

use threads;

$a=threads->create(sub {sleep(5); print("Line1\n");});
$b=threads->create(sub {sleep(4); print("Line2\n");});
$c=threads->create(sub {sleep(3); print("Line3\n");});
$d=threads->create(sub {sleep(2); print("Line4\n");});

$a->join();
$b->join();
$c->join();
$d->join();

22
Questo non è teoricamente garantito per la stampa in ordine inverso esatto.
Cruncher,

4
@Cruncher Lo so, ma con 1 secondo di spazio le possibilità di stampa in qualcosa di diverso dall'ordine inverso sono piuttosto scarse.
Gareth,

3
@Gareth Ecco perché ho teorizzato il corsivo in teoria :)
Cruncher,

3
@Cruncher Non è questo che lo rende così divertente?
Pierre Arlaud,

@ Cruncher allo stesso modo in cui teoricamente i miei atomi potrebbero passare attraverso un muro?
cdeange,

37

HTML + CSS

<p>Line 1</p>
<p>Line 2</p>
<p>Line 3</p>
<p>Line 4</p>

CSS:

body {margin-top:7em}
p + p {margin-top:-4em}

Vedi jsFiddle .

Modifica:
per conformarsi meglio alle regole, ecco una variante in XML, che effettivamente utilizza print.

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="style.css"?>
<root>
  <print>Line 1</print>
  <print>Line 2</print>
  <print>Line 3</print>
  <print>Line 4</print>
</root>

dove dovrebbe essere style.css

* {display:block; margin-top:3em}
print + print {margin-top:-3em}

HTML senza CSS

E per diamine, eccone uno senza CSS.

<table>
<tfoot><tr><td><table><tfoot><tr><td>Line 1</tr></tfoot>
<tbody><tr><td>                      Line 2</table></tfoot>
<tbody><tr><td><table><tfoot><tr><td>Line 3</tr></tfoot>
<tbody><tr><td>                      Line 4</table></tbody>
</table>

Violino .


2
Qualcuno può spiegare il downvote? Questo funziona quando si stampa, lo sai.
Lister,

Puoi anche farlop {float:right;}
Noyo,

Ma poi i risultati saranno tutti su una riga!
Lister,

... e questo è permesso. :]
Noyo,

1
... e questo non è vietato. : D Potresti anche inserirlo in un div e aggiungere la regola CSS div {float:left}.
Noyo,

23

C ++

#include <iostream>
#define Q(x,y) x ## y
#define P(x,y) Q(x, y)
#define print S P(s, __LINE__) =
struct S { const char *s; S(const char *s): s(s) {} ~S() { std::cout << s << std::endl; } };
int main() {
    print "Line1";
    print "Line2";
    print "Line3";
    print "Line4";
}

(Le variabili locali vengono distrutte in ordine inverso rispetto alla dichiarazione.)

C ++ 11

#include <iostream>
int main() {
    struct S { void (*f)(); S(void (*f)()): f(f) {} ~S() { f(); } } s[] = {
        {[](){ std::cout << "Line1" << std::endl; }},
        {[](){ std::cout << "Line2" << std::endl; }},
        {[](){ std::cout << "Line3" << std::endl; }},
        {[](){ std::cout << "Line4" << std::endl; }},
    };
}

(Più o meno lo stesso, ma usando invece lambdas e un membro di dati dell'array.)


Ho pubblicato una soluzione usando std::functione stavo cercando di liberarmene. Ora non ho bisogno perché ce l'hai!
sergiol

21

Haskell

main = sequence_ $ reverse [
    putStr "Line1",
    putStr "Line2",
    putStr "Line3",
    putStr "Line4"]

21

Javascript

setTimeout(function(){console.log("Line 1");},900);
setTimeout(function(){console.log("Line 2");},800);
setTimeout(function(){console.log("Line 3");},700);
setTimeout(function(){console.log("Line 4");},600);

L'uso 1,2,3,4come timeout funziona anche per me. (Tuttavia, non so se questo comportamento sia standardizzato in ECMAScript.)
ComFreek,

1
@ComFreek: setTimeoutè standardizzato in HTML5 / timer, non in ES. Inoltre, specifica un timeout minimo di 4ms :-)
Bergi,

1
@Bergi Sì, hai ragione, ovviamente! HTML standard - Timer - se qualcuno è interessato.
ComFreek,

1
Eseguilo su una macchina abbastanza lenta (diciamo, un 8086 che esegue diverse altre applicazioni?) E fallirà. (Per errore, intendo che l'ordine non verrà invertito, poiché ci vorranno> = 100ms per eseguire ogni istruzione.
Jeff Davis,

1
@ lastr2d2 La simulazione di un computer lento con loop while è abbastanza soggettiva, ma penso che questo sarebbe più simile: jsfiddle.net/7zbKw/1 . Nota da whatwg.org/specs/web-apps/current-work/multipage/… "Questa API non garantisce che i timer funzionino esattamente nei tempi previsti. Si prevedono ritardi dovuti al carico della CPU, ad altre attività, ecc."
Jeff Davis,

20

C

Cercare di rendere la sfida dei suggerimenti nella domanda il più creativa possibile:

#include <stdio.h>
#define print if (i == __LINE__) puts
static unsigned i;
int main(void) {
  while (--i) {
    print("Line 1");
    print("Line 2");
    print("Line 3");
    print("Line 4");
  }
  return 0;
}

3
bel abuso di un #define: P +1
masterX244,

15

BF

Presuppone il wrapping delle celle.

++++[->+
----[> (line 1) .[-]<]++++
---[> (line 2) .[-]<]+++
--[> (line 3) .[-]<]++
-[> (line 4) .[-]<]+
<]

Perché funziona

La prima e l'ultima riga compongono un ciclo che si ripete quattro volte (counter = cell0).

All'interno del ciclo è presente una variabile contatore ( cell1) che viene aumentata ad ogni corsa.

Ogni riga controlla se diminuisce di quattro, tre, due o uno è uguale a zero. Pertanto, al primo giro, il contatore è uno e l'ultima riga viene eseguita, al secondo giro viene eseguita la terza riga, ecc.

Gli (line 1)spettacoli in cui si dovrebbe fare il testo che viene stampato. Le frecce nei loop assegnano cell2a questo scopo. Lo [-]pulisce cell2dopo averlo usato.


14

bash

In memoria del riverito SleepSort e SleepAdd , vi presento ... SleepReverse :

#!/bin/bash

function print(){(sleep $((4-$1));echo "Line $1";)&}

print 1
print 2
print 3
print 4

Affinché assomigli di più alle specifiche, usa $1e $2: function print(){(sleep $((4-$2));echo "$1 $2";)&}; print Line 1
ThinkChaos,

13

Giava

import java.io.PrintStream;
import java.util.concurrent.FutureTask;

public class Print {
  public static void main(String[] args) {
    new FutureTask<PrintStream>(new Runnable() {
      public void run() {
        new FutureTask<PrintStream>(new Runnable() {
          public void run() {
            new FutureTask<PrintStream>(new Runnable() {
              public void run() {
                System.out.append("Line1"); }
            }, System.out.append("Line2")).run(); }
        }, System.out.append("Line3")).run(); }
    }, System.out.append("Line4")).run();
  }
}

È tutto nei tempi giusti ... ;-)


Le linee devono essere adiacenti.
Timtech,

Non sono meno adiacenti che ad esempio con codegolf.stackexchange.com/a/20660/16293 nessuno ha detto che dovrebbero apparire uguali. Rimuoverà alcuni personaggi newline ;-)
TheConstructor

Ok, fantastico :-)
Timtech,

12

Python 3

import atexit

atexit.register(print,"Line1")
atexit.register(print,"Line2")
atexit.register(print,"Line3")
atexit.register(print,"Line4")

12

bash

Ecco la sceneggiatura a doppia faccia:

#!/bin/bash
s=1
if [ $s -ne 0 ]; then tac $0 | bash; exit; fi
s=0
echo "Line1"
echo "Line2"
echo "Line3"
echo "Line4"

2
Non sapevo nemmeno che tacesistesse! Haha grazie.
Noyo,

11

Lisp comune № 1

È facile scrivere una ngorpmacro che esegue i suoi moduli in ordine inverso:

(macrolet ((ngorp (&body ydob) `(progn ,@(reverse ydob))))
  (ngorp
   (write-line "Line 1")
   (write-line "Line 2")
   (write-line "Line 3")
   (write-line "Line 4")))
Line 4
Line 3
Line 2
Line 1

Lisp comune № 2

Eccone uno che prende il problema alla lettera; il codice dalla domanda appare nel programma senza modifiche:

(macrolet ((execute-prints-backwards (&body body)
             `(progn 
                ,@(nreverse (mapcar (lambda (string)
                                      (list 'write-line string))
                                    (remove-if-not 'stringp body))))))
  (execute-prints-backwards

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

  ))
Line4
Line3
Line2
Line1

10

PHP

Un'altra evalvariante:

$lines=array_slice(file(__FILE__),-4); // get last 4 lines of current file
eval(implode('',array_reverse($lines)));exit; // eval lines reversed and exit
print "Line1\n";
print "Line2\n";
print "Line3\n";
print "Line4\n";

1
Slick! Tuttavia, mi sento in dovere di sottolineare che è una pessima idea.
David Kryzaniak,

9

F #

let inline (?) f g x = g x; f x

(printfn "Line1%s") ?
 (printfn "Line2%s") ?
  (printfn "Line3%s") ?
   (printfn "Line4%s") ""

Ho appena creato un operatore personalizzato che esegue le funzioni in ordine inverso.


3
Sono abbastanza sicuro (?) F (g (x)) = g (x); f (x) è calcolo e non programmazione.
Jeff Davis,

2
@JeffDavis: Abbastanza sicuro (?) f g xlegge approssimativamente come (?)(f, g, x), nof(g(x))
Eric

9

Go (Golang)

package main

import "fmt"

func main() {
    defer fmt.Println("Line 1")
    defer fmt.Println("Line 2")
    defer fmt.Println("Line 3")
    defer fmt.Println("Line 4")
}

Provalo: http://play.golang.org/p/fjsJLwOFn2


Volevo pubblicare lo stesso identico codice. Letteralmente, byte per byte esattamente lo stesso.
Art

@Art, fantastico! Spero di vedere di più Go utilizzato in Code Golf.
cory.todd,

Probabilmente non accadrà. Go non è davvero bravo a essere compresso, limitano deliberatamente costrutti strani in modo da non poter creare un pasticcio illeggibile. Ma in questo caso (e forse altri concorsi di popolarità) ha una possibilità.
Art

8

python3

print("Line1",
print("Line2",
print("Line3",
print("Line4") or '') or '') or '')

Può essere più breve di 6 byte rimuovendo tutti gli spazi nell'ultima riga.


7

Javascript

[
  "console.log('Line1')",
  "console.log('Line2')",
  "console.log('Line3')",
  "console.log('Line4')"
].reverse().forEach(function(e){eval(e)})

C ++ 11

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<std::function<void()>> functors;
    functors.push_back([] { std::cout << "Line1"; });
    functors.push_back([] { std::cout << "Line2"; });
    functors.push_back([] { std::cout << "Line3"; });
    functors.push_back([] { std::cout << "Line4"; });
    std::reverse(functors.begin(),functors.end());
    std::for_each (functors.begin(), functors.end(), [](std::function<void()> f) {f();});
    return 0;
}

Invece di std::reversee std::for_each, usa semplicementewhile (! functors.empty()) { functors.back()(); functors.pop_back(); }
David Hammen,

7

Lotto

echo off

call :revers ^
echo.line1 ^
echo.line2 ^
echo.line3 ^
echo.line4

:revers
if not "%2"=="" call :revers %2 %3 %4 %5 %6 %7 %8 %9
%1

Benvenuti su codegolf! Bel post.
Cruncher,

7

C #

Invece di chiamare direttamente il metodo Run, sto creando un metodo dinamico che contiene una copia del bytecode IL di Run, tranne per il fatto che gli operandi opcode della stringa di caricamento vengono scambiati. Il che fa sì che il nuovo metodo visualizzi le stringhe in ordine inverso.

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

namespace TestApp
{
    class Program
    {
        public static void Run()
        {
            Console.WriteLine("Line 1");
            Console.WriteLine("Line 2");
            Console.WriteLine("Line 3");
            Console.WriteLine("Line 4");
        }


        static void Main(string[] args)
        {
            var method = typeof(Program).GetMethod("Run");
            var il = method.GetMethodBody().GetILAsByteArray();
            var loadStringOperands = new Stack<int>();
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    loadStringOperands.Push(BitConverter.ToInt32(il, i + 1));
                    i += 4;
                }
            }

            var run = new DynamicMethod("Run", typeof(void), null);
            var gen = run.GetILGenerator(il.Length);
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    var str = method.Module.ResolveString(loadStringOperands.Pop());
                    gen.Emit(OpCodes.Ldstr, str);
                    i += 4;
                }
                else if (il[i] == OpCodes.Call.Value)
                {
                    var mInfo = method.Module.ResolveMethod(BitConverter.ToInt32(il, i + 1)) as MethodInfo;
                    gen.Emit(OpCodes.Call, mInfo);
                    i += 4;
                }
                else if (il[i] == OpCodes.Ret.Value)
                {
                    gen.Emit(OpCodes.Ret);
                }
            }

            run.Invoke(null, null);
        }
    }
}

6

Pitone

ancora un'altra soluzione che utilizza eval()

a = [
"print('Line1')",
"print('Line2')",
"print('Line3')",
"print('Line4')"]

for line in reversed(a):
    eval(line)

non è molto complesso, ma facile da capire.


2
l'unico codice che capisco: D
moldavo
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.