Un'altra brillante domanda di Stack Overflow si è trasformata in una sfida di code-golf !

Scrivi un programma che:

1. Accetta una stringa come input dell'utente (non reindirizzato o argomento della riga di comando). Il tipo di dati dell'input deve essere una stringa, se la lingua esegue automaticamente la valutazione dell'input, deve essere trasmessa a una stringa.
2. Trova l'indice (basato su 0 o 1) della prima cifra pari più bassa .
3. Stampa 2 numeri interi , l'indice e la cifra pari più bassa .
4. Se non vi è alcuna cifra pari , restituisce -1 come indice, il secondo numero può essere qualsiasi cosa.
5. Ai fini di questo zero non è pari .

Esempi di test, data la stringa a sinistra, emette i valori a destra:

25376  -->  0,2
523726 -->  1,2
583746 -->  4,4
53771  --> -1,0
_4___2 -->  5,2

Il vincitore: è il programma con il numero di caratteri più basso. Nessun bonus, nessuna penalità.

edit: (circa stdin) Ho rovinato la parte di input dell'utente, praticamente nessun dato di piping e nessun argomento da riga di comando. È necessario fornire un prompt utente di qualche tipo all'interno del programma stesso.

Golfscript, 26 (28) caratteri

'#{gets}'.'246'&8+$1<.@\?

Esempio:

;'583746'
.'246'&8+$1<.@\?
#44

;'53771'
.'246'&8+$1<.@\?
#8-1

live test: http://golfscript.apphb.com/?c=Oyc1Mzc3MScKLicyNDYnJjgrJDE8LjA9QD8%3D

Spiegazione:

• '#{gets}'è una via di fuga dal rubino per soddisfare i requisiti I / O; Si presume che STDIN sia vuoto
• . clona l'input
• '246'&8+trova quali cifre pari sono presenti nell'input, tranne che 8è sempre conservato
• $1< ordina l'elenco, quindi accetta la prima cifra, ma la mantiene come una stringa
• .@\?ordina lo stack {cifra, input, cifra}, quindi trova la cifra nell'input; grazie @peterTaylor per avermi notato la firma [array, array] di ?.

Questa volta sono stato molto audace con l'interpretazione delle specifiche; vale a dire:

• La specifica non impone in quale ordine vengono stampati gli interi; Usa il suggerimento dell'altro @ peter :x?xper correggere (non mi piacciono le variabili temporanee.
• La specifica non richiede alcun delimitatore tra i due numeri interi; poiché la cifra trovata è sempre una singola cifra, questo non ha molta importanza. In tal caso, aggiungi n@(che esegue anche lo scambio), n\(che non lo fa) o ]`(che formatta l'output come ["8" -1]).

APL (37)

(1 basato per impostazione predefinita, ma obbedisce ⎕IO)

{×⍴m←⍵/⍨⍵∊'2468':z,⍨⍵⍳⍕z←⌊/⍎¨m⋄¯1,0}⍞

Spiegazione:

• ⍞: leggi l'input dell'utente
• m←⍵/⍨⍵∊'2468': rimuovi tutti i personaggi che non lo sono 2468, archivia m.
• ×⍴m: vedi se ce ne sono
• :: Se è così:
  • z←⌊/⍎¨m: valuta ogni personaggio in m, trova il numero più basso e memorizza in z.
  • z,⍨⍵⍳⍕z: restituisce l'indice di zin ⍵, seguito da z.
• ⋄: Altrimenti:
  • ¯1,0: ritorno (-1, 0)

Python 3, 69

combinando idee da qui .

s=input();print(([(s.find(x),x)for x in'2468'if x in s]+[(-1,0)])[0]) 

Rubino, 60 caratteri

x=gets.chars.sort.find{|c|c=~/[2468]/};p x ?$_.index(x):-1,x

• $_contiene l'ultimo input letto da gets.
• pchiama inspectgli argomenti e stampa i risultati.

perl - - 94 - 53 caratteri (o 48)

Invece dell'approccio index()a base zero usiamo pose iniziamo da uno; nessun CPAN. Esegui questo perl -nEe attenderà l'input (che può anche ricevere da STDIN).

La prima //operazione match ( ) funziona sul valore predefinito ( $_) dall'input, facendo corrispondere i numeri pari dati, sortinserendo le corrispondenze in un array e quindi memorizzandole in un "elenco scalare" ($m). Nel contesto scalare il valore di elenco dell'array ordinato è lungo un elemento e pertanto è costituito dalla cifra pari corrispondente più bassa nel numero.

Dopo aver isolato la cifra corrispondente anche più bassa, utilizziamo quindi $mper una seconda operazione di corrispondenza che troverà la prima occorrenza del valore di $mnella stringa originale. Stiamo ancora usando il valore predefinito qui $_e stiamo salvando la corrispondenza con il contenuto di $min $1(il motivo per il ()giro $mnella seconda istruzione). Dopodiché, pose sayfai il resto (e in meno personaggi di indexe print).

perl -nE'($m)=sort/[2468]/g;/($m)/g;$1?say pos.",$1":say"-1,0"'
33467
3,4

Se l'ordine di output o le virgole non contano, è possibile accorciare questi 5 caratteri:

($m)=sort/[2468]/g;/($m)/g;$1?say$1.pos:say"-10"

Nel mio tentativo precedente mi sono precipitato e ho commesso un errore: volevo solo battere pitone e rubino (ma non ci sono riuscito) ... sospiro.

Complimenti al vincitore e agli altri partecipanti per le loro fantastiche soluzioni, in particolare per perl6:-) Un possibile adattamento Perl6 di questo approccio potrebbe usare " .comb(suggerito su freenode da Masak et.al. ).

$_=get;my $n=.comb(/<[2468]>/).min;/$n/;say $/.from//-1,",$/"

Perl 6, 37 55 60 caratteri

$_=get;say m/<{~.comb(/<[2468]>/).min}>/.from//-1,',',$/.Int

EDIT: ho frainteso la domanda la prima volta. Questo aggiornamento dovrebbe essere corretto. Trova il numero più basso di 2,4,6, o 8 contenuto nell'input, e quindi fa una corrispondenza regex con l'input con quel numero più basso. $/.fromottiene la posizione della corrispondenza ed ',', $/.Intè una virgola più la corrispondenza stessa, oppure 0 se il testo non corrisponde.

Mentre sei qui, vota G. Cito , che mi ha aiutato a correggere la mia voce nei commenti e su irc :)

J, 44 caratteri

echo(;{&i){._1,~(#~(#i)&>)'2468'i.~i=.1!:1]1

emette l'ultimo carattere dell'ingresso se non viene trovata alcuna cifra pari

Esempio:

   echo(;{&i){._1,~(#~(#i)&>)'2468'i.~i=.1!:1]1
523726
+-+-+
|1|2|
+-+-+
   echo(;{&i){._1,~(#~(#i)&>)'2468'i.~i=.1!:1]1
53771
+--+-+
|_1|1|
+--+-+

Spiegazione:

• echo ... i=.1!:1]1è input / output. Molto più a lungo di quanto io voglia. Anche l'input viene nascosto i.
• '2468'i.~ trova la prima occorrenza di ogni cifra pari nell'input, restituendo la lunghezza dell'input se non è possibile trovare la cifra
• (#~(#i)&>)legge "seleziona per la lunghezza dell'input maggiore di questo"; in altre parole, selezionare quegli indici che puntano all'input. Molto più a lungo di quanto io voglia.
• _1,~aggiunge -1 alla parte posteriore. Underscore è il modo in cui J rappresenta i valori negativi.
• {. seleziona il primo elemento
• (;{&i)lo concatena con il carattere di input in quella posizione in due caselle; poiché stiamo concatenando un numero con un personaggio, la concatenazione non boxe ( ,) non lo farà. Se si desidera visualizzare unbox, l'indice deve essere prima formattato ( ":) al costo di due caratteri.

Python 2.7 - 76

Una risposta di riferimento mi aspetto pienamente di essere battuto. Ma per iniziare le persone:

s=raw_input()
print[(s.index(`e`),e)for e in[2,4,6,8]if`e`in s][:1]or(-1,0)

R, 104

y=as.integer(strsplit(scan(,""),"")[[1]]);z=which(!y%%2&y);a=z[which.min(y[z])];cat(a,"-1 0"[!sum(a)],y[a])

Esempi (in R, l'indice inizia da 1):

_4_502
6  2

_3_501
-1 0 

583746
5  4

Powershell, 76 73 71

$s=read-host;2,4,6,8|%{if($i=$s.indexof("$_")+1){"$i,$_";break}};"-1,0"

• $s=read-host memorizza l'input dell'utente in $s
• 2,4,6,8|%{...} esegue ciò che è dentro {}per le cifre 2,4,6 e 8
• $i=$s.indexof("$_")+1 imposta $iun indice basato su 1 di una cifra in $so 0se la cifra non viene trovata
• if( $i=... ){...} la condizione sarà vera quando $inon lo è0
• "$i,$_";break genera l'indice e la cifra e interrompe l'esecuzione
• "-1,0" altrimenti uscite -1,0

C ++ 11, 173 (inclusi due caratteri di nuova riga)

Ecco la versione compressa:

#include<iostream> 
#include<string> 
int main(){std::string s;std::cin>>s;for(char c:"2468")for(char&k:s)if(k==c){std::cout<<(&k-&s[0])<<','<<c;return 0;}std::cout<<"-1,8";}

Ecco la versione leggibile:

#include<iostream>
#include<string>
int main() {
    std::string s; // auto s = ""s; (since C++14: -3 characters)
    std::cin >> s;
    for (char c : "2468")
        for (char& k : s)
            if (k == c) {
                std::cout << (&k - &s[0]) << ',' << c;
                return 0;
            }
    std::cout << "-1,8";
}

Ecco una versione precedente:

C ++ 11, 175 (inclusi due caratteri di nuova riga)

Ecco la versione compressa:

#include<iostream>
#include<string>
int main(){std::string s;std::cin>>s;for(char c:"2468"){int i=s.find(c);if(i<s.size()){std::cout<<i<<','<<c;return 0;}}std::cout<<"-1,8";}

Ecco la versione leggibile:

#include<iostream>
#include<string>
int main() {
    std::string s;
    std::cin >> s;
    for (char c : "2468") {
        int i = s.find(c);
        if (i < s.size()) {
            std::cout << i << ',' << c; 
            return 0;
        }
    }
    std::cout << "-1,8";
}

C, 80 caratteri

main(){char a[81],b=strcspn((gets(a),a),"2468");printf("%d,%c",a[b]?b:-1,a[b]);}

C # - 124

Sono un po 'in ritardo alla festa

void Main(string[]a){var x=a[0].Where(w=>char.IsDigit(w));var y=x.Min();Console.Write(y%2==0?a[0].IndexOf(y)+","+y:"-1,0");}

Haskell, 79 caratteri

s&d=filter((==d).snd)$zip[-1..]$'0':s
main=interact$show.head.("24680">>=).(&)

Questo funziona un po 'veloce e sciolto con la formattazione dell'output:

& echo 523726 | runhaskell 16083-LowEven.hs 
(1,'2')
& echo 583746 | runhaskell 16083-LowEven.hs 
(4,'4')
& echo 53771 | runhaskell 16083-LowEven.hs 
(-1,'0')
& echo _4___2 | runhaskell 16083-LowEven.hs 
(5,'2')
& echo 25376 | runhaskell 16083-LowEven.hs 
(0,'2')

PowerShell: 145 103

Modifiche rispetto all'originale
Rimosso errore quelch per commento da chi chiede .

Codice:

"$([array]::IndexOf(($s=(read-host)-split''|?{$_}),($x=$s|?{$_%2-eq0}|?{$_-gt0}|sort|select -f 1))),$x"

Procedura dettagliata:

"... "Tutto tra virgolette verrà incluso nell'output.

$(... )Tutto tra parentesi verrà trattato come un comando e l'output di quel codice verrà incluso al posto dei comandi stessi.

[array]::IndexOf(... )Questo è usato per ottenere l'indice di un elemento con l'array. Il suo primo parametro è l'oggetto array da cercare. Il secondo parametro è l'oggetto da trovare. Questo genera solo l'indice del primo elemento corrispondente. Ho provato semplicemente ad usare un IndexOfmetodo direttamente contro $s(es. $s.IndexOf($x), Ma questo non riesce per qualche motivo che devo ancora capire - afferma che il metodo non esiste su quell'oggetto.

(... L' )espressione tra parentesi sarà il primo parametro per IndexOf.

$s= $ s sarà una variabile per memorizzare l'input dell'utente.

(read-host)-split'' Ottiene l'input dell'utente e lo divide in una matrice di caratteri

|?{$_}Filtra elementi dell'array extra vuoti generati da -split''.

,(... L' )espressione tra parentesi sarà il secondo parametro per IndexOf.

$x= $ s sarà una variabile per memorizzare la cifra pari più bassa dall'input dell'utente.

$s|?{$_%2-eq0} Estrae i numeri pari da $ s.

|?{$_-gt0} Invalida lo zero.

|sort Ordina gli oggetti rimanenti, l'ordine predefinito è crescente.

|select -f 1 Seleziona il primo oggetto, che sarà ormai la cifra pari più bassa.

,$xIl codice sopra emetterà l'indice della nostra cifra pari più bassa. Ciò aggiunge una virgola e quindi genera la cifra stessa.

Appunti:

Questo forse sta allungando un po 'la regola 4. Se non ci sono cifre pari, l'output non includerà un secondo numero.

Inoltre, ciò genererà alcuni errori non terminanti se l'input include elementi non numerici. Lo script sarà ancora correre e dare l'uscita corretta, ma si potrebbe desiderare di serie $ErrorActionPreferenceper 'SilentlyContinue'prima di eseguirlo.

vb.net (108c)

Sub Main()
t=ReadLine()                          '12c
For Each c In "2468"                  '20c  
i=t.IndexOf(c)                        '14c
If i>=0 Then Exit For                 '21c
Next                                  ' 4c
WriteLine("{0},{1}",i,If(i<0,0,t(i))) '37c
End Sub

Odora leggermente perché sta sfruttando l'impostazione dinamica di VB. Opzione Off esplicito e importazioni System.Console .

VB.net (193c) usando LINQ

Questo utilizza principalmente una query LINQ.

Dim r = From d In "2468" Group Join q In ReadLine.Select(Function(c, p) New With {.c = c, .i = p})
                              On d Equals q.c Into g = Group
                                        Skip While g.Count = 0 ' 138c
WriteLine(If(r.Any,r(0).g(0).i&","&r(0).g(0).c,"-1,0"))        '  55c

Golf-Basic 84, 91 caratteri

:L1/L1_L2i`L1:fpart(L1,2)2_L1:SortA(L1)@cumSum(L1)=length(L1):Thend`-1#d`cumSum(L1):Endd`L1

• Assicurati che non ci sia 0nell'input (non è nemmeno, chi ha detto che doveva essere strano?)
• Ottieni input in L1 (Elenco 1)
• Modulo di ricerca loop di 2 per ciascun valore
• Ordina L1 dal più piccolo al più alto
• Visualizza l'indice (-1 o la somma cumulativa) e il numero più piccolo

Bourne shell (sh), 88 caratteri

(echo 88;sed 's/./\n&/g')|nl -v-1|awk '{print $2,$1}'|sed '/^[^2468]/d'|sort -n|head -n1

Ho pensato di fare una cosa di elaborazione delle stringhe per divertimento. Tecnicamente legge da stdin, ma se lo esegui in modo interattivo richiederà all'utente l'immissione poiché la tastiera è il flusso stdin predefinito. Usa i comandi di base della shell per dividere l'input su righe, numerarle (usando l' nlutilità sconosciuta ), filtrare le righe che soddisfano i criteri, ordinarle e produrre quella con la cifra più bassa. Stampa 88 -1se non è stata trovata alcuna cifra pari.

C ++ - 223 221 Personaggi:

#include<iostream>
#include<string>using namespace std;
int main(){int s=9;int p=-1;string x;cout<<"Enter characters: ";cin>>x;for(int i=0;i<x.length();i++){int n=x[i]-48;if(n%2==0&n<s){s=n;p=i;}}cout<<p<<", "<<s;return 0;}

Versione leggibile:

#include<iostream>
#include<string>
using namespace std;

int main() {
    int s = 9;
    int p= - 1;
    string x;

    cout << "Enter characters: ";
    cin >> x;

    for (int i = 0; i < x.length(); i++) {
        int n = x[i] - 48;

        if (n % 2 == 0 & n < s) {
            s = n;
            p = i;
        }
    }

    cout << p << ", " << s;

    return 0;
}

È lungo, ma non così male come Java.

Javascript 93 caratteri

b=prompt();((r=b.match(/[2468]/g)||[-1]).sort(function(a,b){return a-b})[0])+","+b.indexOf(r)

Ottieni tutti i numeri di evento, ordina l'array e stampa la prima cifra.

Mathematica, 157 caratteri

f = Row@{If[(x = Min@#) == Infinity, -1, Position[#, x][[1, 1]]],
      ",", x} &[IntegerDigits@ToExpression@StringReplace[#,
       {"0" -> "1", x_?DigitQ :> x, _ -> "1"}] /. _?OddQ -> Infinity] &

inputs = {"25376", "523726", "583746", "53771", "_4___2"}

f /@ inputs // Column

1,2

2,2

5,4

-1, ∞

6,2

Julia, 84

julia> f(a)=(for i=2:2:8;(k=search(a,'0'+i))==0||return(k,i);end;(-1,0))
julia> f(readline(STDIN))
583746
(5,4)
julia> f(readline(STDIN))
_4___2
(6,2)

Julia ha davvero bisogno di un modo più breve per ottenere input per il golf. Ho contato la definizione di fe una chiamata a f. Una indicizzazione basata è il motivo per cui le risposte sono diverse dagli esempi.

JavaScript - 53 caratteri

for(y=prompt(x=0);x<8&&(i=y.indexOf(x+=2))<0;);x+''+i

Legge l'input dal prompt e restituisce (alla console) il carattere pari più basso, quindi (senza delimitatore) il primo indice di quel carattere; se non ci sono caratteri pari a zero, viene emesso 8-1.

C, 110 personaggi

i,f,r,c,m=9;main(){while(r=getchar()>31){c=r-48;i++;if(c>=0&&~c&1&&c<m)m=c,f=i;}printf("%i,%i",m>8?-1:f-1,m);}

ungolfed:

i,f,r,c,m=9;
main(){
  while(r=getchar()>31){
    c=r-48;
    i++;
    if(c>=0&&~c&1&&c<m) m=c,f=i;
  }
  printf("%i,%i",m>8?-1:f-1,m);
}

Javascript, 69

a=prompt(),b=[-1,9];for(i in a)if(+a[i]%2==0&&+a[i]<b[1])b=[+i,+a[i]]

Legge il valore, scorre ogni carattere, se la rappresentazione numerica mod 2 è uguale a 0 e il numero è inferiore a quello già memorizzato b, sostituire i valori inb

Rebol, 69

s: input for n 2 8 2[if f: find s n[print[index? f f/1]q]]print[-1 0]

Ruby 55

p gets.chars.sort*''=~/[2468]/?[$_.index($&),$&]:[-1,0]

JavaScript / jQuery 149

golfed

$(function(){
var i=prompt(),k=-1,n=0,c,e="2468";
while(n<i.length){c=i.charAt(n);k=e.indexOf(c);if(k>=0){break;}n++;}$('#d').append(k+","+n);
});

Fonte completa

<!DOCTYPE html>
<html>
<head>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
</head>
<body>
<div id="d"></div>
<script type="text/javascript">
$(function(){
var i=prompt();
var k=-1;
var n=0;
var c;
var e="2468";
while(n<i.length){
c=i.charAt(n);
k=e.indexOf(c);
if(k>=0){
break;
}
n++;
}
$('#d').append(k+","+n);
});
</script>
</body>
</html>