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 di un concorso di popolarità , 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 :)

Commodore 64 BASIC

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

PHP

Precedenti abusanti ... :-)

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

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 :)

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 .

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))));
}

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

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;
}

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)))

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;

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"

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();

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 .

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.)

Haskell

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

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);

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;
}

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.

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

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 ... ;-)

Python 3

import atexit

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

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"

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

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";

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.

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

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.

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;
}

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

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);
        }
    }
}

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.