La terza stringa


45

Date due stringhe, genera una terza stringa che non è uguale a nessuno dei due input, ma ha la stessa lunghezza (in caratteri) di uno degli input. È garantito che vi sia almeno un output valido.

Casi test

I casi di test sono indicati per mostrare che sono stringhe. Le uscite sono una delle tante possibili.

input, input -> output

"test", "test" -> "tttt"
"do", "don't" -> "dnut_"
"ye s", "yes" -> "fals"
"yes", "yes" -> "noo"
"maybe", "mayue" -> "false"
"false", "false" -> "truee"
"false", "true" -> "fatr"
"1", "" -> "0"
"", "t" -> "s"
"", "abcabc" -> "testst"
"abcdefghijklmnopqrstuvwxyz", "aaaaaaaaaaaaaaaaaaaaaaaaaa" -> "zbcdefghijklmnopqrstuvwxya"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" -> "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"

Regole

  • È possibile scegliere il dominio di input, ma deve essere composto almeno da ASCII stampabile e il dominio di output deve essere uguale al dominio di input.
  • Le lunghezze di input possono essere uguali o diverse.
  • L'output deve essere valido con probabilità 1; vale a dire, puoi generare stringhe casuali fino a quando una non è valida (e teoricamente potresti infinito ciclo), ma non puoi semplicemente generare una stringa casuale e sperare che sia valida. Si noti che ciò significa che l'output non deve essere deterministico.
  • Newline finali automatiche consentite, ma non contano per la lunghezza dell'output.
  • A causa di domande relative agli errori di memoria, deve funzionare entro 60 secondi fino a lunghezze di input di 6. Una risposta che funziona per questo e teoricamente funziona per stringhe più lunghe è OK, ma qualcosa che gli errori di memoria sul computer moderno per la lunghezza dell'input 4non è valido.

Questo è , quindi vince la risposta più breve in byte.


14
Sembra un'altra di un'interessante nuova categoria di domande su questo sito che sono facili per l'uomo e difficili per i computer. Perché i computer non sono bravi a pensare divergenti! Mi ricorda l'episodio di Spongebob in cui è sveglio tutta la notte cercando di scrivere un saggio su cosa NON fare al semaforo.
geokavel,

2
Capisco che il dominio di output può essere un sottoinsieme del dominio di input, sì?
Luis Mendo,

2
Bella domanda! Mi piace.
isaacg,

2
@Quelklef No, non è diverso da entrambi gli input.
Ørjan Johansen,

3
Suggerisco di "", "1" da aggiungere come caso di test, poiché ho appena realizzato che la mia risposta non riesce per questo, anche se funziona per tutti i casi di test forniti
Slow loris,

Risposte:



14

Haskell, 43 byte

x!y=[s|s<-(<$max x y)<$>"abc",s/=x,s/=y]!!0

Prende la stringa massima (lessicograficamente in seguito), che sappiamo essere non vuota; sostituisce tutti i caratteri con uno dei "a", "b" e "c" usando <$; e restituisce il primo che non è nessuno degli input. Penso che questo sia simile alla risposta al carbone di Neil e / o alla risposta CJam di geokavel .

(Sono in agguato da un po ', ma questa è la prima volta che rispondo su questo sito; ciao!)


9

Brainfuck, 97 byte

+>+[-,[>>,]<<[<<]>]>>[>]<<<[<]>[<+>>[-<+<+>>][>]<[->+<]<[-]>>>++<[<]>[.>>]>[>>]]>[+[>]+[<]>[.>>]]

Esegui il codice online (nota che la "memoria dinamica" deve essere selezionata in basso a destra)

Sfida fantastica! Ho pensato che sarebbe stato banale ma alla fine è stato davvero difficile. Continuo a tornarci perché sento che dovrebbe esserci un'elegante soluzione BF a 20 byte. A questo punto, sono abbastanza felice di aver (apparentemente) fatto funzionare tutto in BF.

L'input viene preso come str1+ \0+ str2, dove le stringhe sono caratteri consecutivi diversi da zero a 1 byte.

Ritorni (first str1 + first str2) or (first str1 + 1) or 2. Questo algoritmo è stato ideato dal brillante @ ØrjanJohansen, (presumibilmente) basato sul mio (rotto) originale.

ha commentato:

# Let (Kn) be the nth character of K
# Let (^) designate the pointer
# Let F be the first string inputted
# Let S be the second string inputted

+>+[-  # Twice do
,[>>,]  # Input string (characters separated by 1)
<<[<<]>  # Go to left of beginning of string
]>  # End on first character of second string
# If second string is null we will end one too far to the left
>[>]<<<[<]>  # If first string is null we will end there too
# We will use this to do flow control

[  # Only run if both strings were non null

# Tape:    S0 ' F0 ' S1 ' F1 ' S2 ' F2 ' etc
#          ^

<+>>  # Let F0* = F0 (plus) 1  (is 1 as of now; F0 will be added later)
[-<+<+>>] # Let A = S0 (plus) F0
# A may or may not be zero
# F0* may or may not be zero
# Tape:    F0* ' A ' 0  ' S1 ' F1 ' etc
#                ^

[>]<[->+<]  # Let B = A or F0*
# B may or may not be zero
<[-]>>  # Clear F0*
# Tape:     0 ' B ' 0 ' S1 ' F1 ' etc    (if A was zero)
#               ^
# OR        0 ' 0 ' B ' s1 ' F1 ' etc    (if A was nonzero)
#                   ^

# Let C = B or 2
# C will be guaranteed nonzero and unique from S0 and F0
>++<[<]>  # Create C
[.>>]  # Print (using S or F; does not matter)

>[>>]  # End on a zero cells with zero cells all to the right
# This is necessary for the coming functionality
# also as to not loop
]  # End non null block

# Now we consider if one of the strings was null
# Tape:    0 ' E0 ' 0 ' E1 ' etc    (if one string was null)
#          ^
# Tape:    0 '  0 ' 0 '  0 ' etc    (if neither string was null)
#          ^
# Where E is F or S (we don't care)

>[  # Execute only if one string was null

+  # Let A = E0 (plus) 1
# A may or many not be zero
# Tape: 0 ' A ' 0 ' E1 ' etc
#           ^

[>]+[<]>  # Let B = A or 1
# B is guaranteed nonzero and != E0
# Tape: 0 ' B ' ? ' E1 ' 0 ' E2 ' etc
#           ^

[.>>]  # Print

# End on zero cell as not to loop
]  # End null block

Il vostro "fatto" è sbagliato, ad esempio a=2, b=1. Devi aggiungere invece di sottrarre.
Ørjan Johansen,

Penso che puoi risolvere il Sproblema vuoto aggiungendo >all'inizio e successivamente facendo [<]>sul byte più a sinistra di S- se questo è diverso da zero non fa nulla, altrimenti cambia le stringhe.
Ørjan Johansen,

@ ØrjanJohansen Oh, hai ragione, può eguagliare b. Ma non a.
Quelklef,

@ ØrjanJohansen Ah, sembra funzionare! Pensare bene!
Quelklef,

@ ØrjanJohansen Seguire il fatto: dato che è != asolo, se stampo S/0, S/1, ...invece S/0, F/1, ...che dovrebbe funzionare.
Quelklef,


5

Python 3 , 62 47 57 54 51 byte

Modifica: - 5 byte grazie a @ Mr.Xcoder

Modifica: +10 byte per correggere un bug

Modifica: -3 byte grazie a @betaveros

Modifica: -3 byte usando max invece di pop

lambda x,y:max({*"abc"}-{x[:1],y[:1]})+max(x,y)[1:]

Provalo online!


{"a","b","c"}==> {*"abc"}( 57 byte )
Mr. Xcoder il

(x[1:]or y[1:])==> max(x,y)[1:]?
betaveros,

O semplicemente (x or y)[1:], penso che devi solo evitare la stringa vuota.
betaveros,

Per inciso, è un peccato Python 2 non ha letterali set stellati, perché ho davvero voglia di golf {*"abc"}in {*`id`}...
betaveros

Salva 1 con *len(x or y)invece di +max(x,y)[1:].
Chas Brown,

4

Carbone , 22 byte

FEα×ι⌈⟦LθLη⟧¿¬№⟦θη⟧ιPι

Provalo online! Il collegamento è alla versione dettagliata del codice. Genera tutte le stringhe di caratteri maiuscoli ripetute per la lunghezza dell'input più lungo e sovrastampa tutte quelle che non compaiono nell'input. In altre parole, l'output è normalmente a ZZZ...meno che non sia uno degli input, nel qual caso è a YYY...meno che non sia l'altro input, nel qual caso lo è XXX....


4

Mathematica, 111 byte

(c=Characters;a=#2;While[f=Alphabet[]~RandomChoice~Length@#;f==#||f==c@a]&[#&@@c@{##}~MaximalBy~Length];""<>f)&


provalo online (incolla il codice con ctrl + v, inserisci l'input alla fine e premi maiusc + invio)

ingresso

["mettermi alla prova"]

grazie @Non un albero per il controllo e il golf -21 byte


Come posso testarlo di nuovo online?
Stephen,

link + info aggiunti
J42161217

@Jenny_mathy Sembra fallire se la prima stringa è la stringa vuota
Halvard Hummel,

2
@HalvardHummel fixed!
J42161217

1
@Notatree fixed. Se pensi che il "golf facile" sia una ragione per il downvoting, allora sei il benvenuto
J42161217

4

Perl 6 , 38 30 byte

{(1 x.max.comb...*∉$_).tail}

Provalo online!

Blocco codice anonimo che accetta input come un elenco di due stringhe e restituisce il primo numero 1111...con un numero non vuoto di 1s che non è presente nell'input.

Spiegazione:

{                          }   # Anonymous code block
  1 x.max.comb                 # String multiply 1 by the size of the non-empty string
              ...              # Create a sequence increasing by 1
                 *∉$_          # Until the number is not in the input
 (                   ).tail    # And take the last number

L'incremento è un tipo bigint o questo trabocca per stringhe sufficientemente grandi?
GammaFunzione

1
@GammaFunction In Perl 6, il tipo di numero predefinito è Int, che ha una precisione infinita
Jo King

Oh bello. Stavo per adattarlo a Zsh, ma long longsfortunatamente lo usa .
Funzione gamma

Puoi tagliare 6 byte semplicemente prendendo il primo di 00 .., 111 .., 22 .. invece di contare e sequenze: tio.run/…
Phil H

@PhilH Buona idea! L'ho abbreviato un po 'di più mantenendo l'idea della sequenza
Jo King,

4

Zsh , 51 47 37 36 byte

-4 byte usando l'array incorporato argv, -10 byte usando la rimozione del prefisso e RC_EXPAND_PARAM, -1 byte incorporando l'espansione del controvento.

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}

Provalo online!

Innanzitutto, questa è stata una sfida fantastica, ho affrontato moltissime idee prima di approdare su questa.

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}
       ${:-             }            # empty fallback
                 ${ @#?}             # remove first character from each parameter
                 ${^@  }             # enable brace expansion (set -P)
           {1..3}${^@#?}             # expand to 1foo 2foo 3foo 1bar 2bar 3bar
     ${                  :|argv}     # Set difference with 'argv'
   ${                           [1]} # The first found element
<<<                                  # print to stdout

@e *non sono identificatori, quindi ${ :|@}e ${ :|*}non funzionano, quindi l'uso di${ :|argv}

Questo metodo funzionerà fino a 93 input e troverà un 94 ° che è unico. Sostituisci semplicemente il {1..3}con la gamma massima possibile {~..!}.

Zsh , 48 47 byte *

for ((;$#i<${#${1:-$2}}||$@[(I)$i];i++)):
<<<$i

Provalo online!

Metodo completamente nuovo per gentile concessione dell'invio di Perl 6 di JoKing, ma non funziona su stringhe di grandi dimensioni (n> 20) a causa delle restrizioni sulle dimensioni intere. $@[(I)$i]è la ricerca inversa dell'array al più grande indice, produrrà zero (falsa nell'espansione aritmetica) se $ i non viene trovato nei parametri della riga di comando.


3

MATL , 12 byte

c"1Y2@X-1)&h

L'input è un array di celle di stringhe contenente caratteri ASCII stampabili. L'output è formato dalle lettere 'ABC'e quindi appartiene al dominio di input.

Provalo online!

Spiegazione

L'output è lungo quanto la stringa di input più lunga. Il suo n carattere esimo è la prima lettera da 'ABC'che è diverso dal n carattere -esimo di entrambe le stringhe di input.

c        % Concatenate the two strings vertically. If one is shorter it is
         % right-padded with spaces. Gives a 2-row character matrix
"        % For each column
  1Y2    %   Push the string 'ABC...Z' (the upper-case letters)
  @      %   Push current column
  X-     %   Set difference
  1)     %   Get first character
  &h     %   Horizontally concatenate the results so far
         % End (implicit). Display stack (implicit)

3

Haskell, 56 52 48 byte

x#y|_:t<-max x y=[c:t|c<-"abc",c:t/=x,c:t/=y]!!0

Provalo online!

Sostituire il primo carattere della massima delle due stringhe di input con a, be cscegliere il primo che è diverso da entrambe le stringhe di input.



3

ES6, 54 byte

a=>b=>(a[0]+b[0]|0?'a':9-(a[0]^b[0]))+(a||b).substr(1)

Benvenuto in PPCG :)
Shaggy,

3

Pyth, 7 8 byte

hC-LG.T

1 byte grazie a Jakube

Suite di test

Utilizziamo .Ttrasposizione che preserva la lunghezza anziché Ctroncare la trasposizione, in modo che funzioni su input in cui una stringa è vuota.

Dato due stringhe come tupla, le trasponiamo ( .T), quindi mappiamo la coppia risultante di caratteri o singolo carattere sottraendo i caratteri dall'alfabeto minuscolo con -LG, quindi trasponiamo l'elenco risultante di stringhe di caratteri non utilizzati con C, quindi restituiamo la prima di queste stringhe con h. Questa è composta dalla prima lettera in ordine alfabetico che non si trova in nessuna delle due stringhe, per ogni posizione.



2

Rubino, 56 byte

->a,b{a,b=b,a if a<b;a[0]=([?a,?b,?c]-[a[0],b[0]])[0];a}

2

Pyth , 23 22 byte

+.)-.{<G3.{,<Q1<KE1t|K

Provalo qui!

Pyth , 22 byte

+eS-.{<G3.{,<Q1<KE1t|K

Test Suite!


Spiegazione

+.)-.{<G3.{,<Q1<KE1t|K  - Full program.
      <G3               - Yields the String "abc"; Alphabet[:3].
    .{                  - Set formed by the above.
         .{,<Q1<KE1     - Set formed by input_1[:1] and input_2[:1]
   -                    - Set subtraction.
 .)                     - Pop the last element.
+                       - Append.
                   t|K  - input_1[1:] or input_2[1:], relying on the result of Logical OR.

2

Perl 5, 82 79 byte

sub{$_=$_[0];$_=$_[1]||$_ if/^(xz*)?$/;s/[^z]/z/||s/./y/;$_ eq$_[1]&&s/./x/;$_}

Prende l'input come due argomenti separati e restituisce la terza stringa.

La subroutine tenta di produrre una stringa molto simile alla prima stringa ma con il primo non zcarattere sostituito da a z. Quindi si occupa di casi angolari sostituendo il primo carattere con yo x, se necessario, se trova che uno degli input era in realtà una sequenza di tutti z.


2

Perl 5 , 68 byte

sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}

Spiegazione:

  • inizia con (stringa della lettera "a" fino alla prima stringa) o seconda stringa se ciò è falso, cioè lunghezza zero
  • continua ad incrementarlo fino a quando non è diverso sia dal primo che dal secondo

Partendo da "a" s si evitava di incrementare fino al punto in cui Perl allunga la stringa; con solo due stringhe per evitare di essere lo stesso, non poteva traboccare.

Eseguire con:

perl -e '$s = ' -E 'sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}' -E ';say $s->("z", "true")'

1
Penso che fallirà se la prima stringa è vuota.
Ørjan Johansen,

Giusto! Fisso.
Ed.

2

C (gcc) ,70 65 73 67 61 byte

La funzione richiede che le stringhe fornite siano mutabili (ovvero array o allocati dinamicamente).

f(a,b)char*a,*b;{a=*a?a:b;*a=*a>70?33:99;*a+=*a==*b;puts(a);}

Provalo online!

Funziona con l'intervallo ASCII standard

Spiegazione:

a=*a?a:b           // If a is empty, point to b instead
*a=*a>70?33:99     // Choose a different value for the 1st character of a,
                   // while giving enough space to increment it without 
                   // going back to its previous value
*a+=*a==*b         // Increment the 1st character of a if the arbitrary
                   // chosen value is equal to the value of the 1st 
                   // character of b
puts(a)            // Outputs a

1
Non sono sicuro che a questo possa essere assegnato un dominio di input coerente che soddisfi le regole. E se *a==255e *b==0?
Ørjan Johansen,

Hai ragione. Risolto, al costo di 8 byte.
scottinet,

Là. Non potevo lasciare che questa soluzione avesse lo stesso bytecount di quella Java! :-)
scottinet,

Se non si limita a ASCII stampabile, è possibile utilizzare numeri a una cifra.
Ørjan Johansen,

A meno che non fraintendessi, ciò sarebbe contrario a questa sfida.
scottinet,

2

R, 89 67 byte

@Giuseppe ha salvato 9 byte, @ user2390246 ha salvato 13 byte

funzione

function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

dimostrazione

# define function
f <- function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

# test cases
f("test","test")
[1] "aest"
f("do","don't")
[1] "ao"
f("ye s","yes")
[1] "ae s"
f("maybe","mayue")
[1] "aaybe"
f("false","false")
[1] "aalse"
f("false","true")
[1] "aalse"
f("1","")
[1] "a"
f("art","bug")
[1] "crt"

1
Puoi mettere xe ycon lo stesso substrcomando. Inoltre, le parentesi graffe e returnnon sono necessarie:function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)
user2390246

1
Puoi sbarazzartene returnpoiché questa è una funzione e le parentesi graffe poiché sono una fodera.
Giuseppe,

Scatta, mi sono appena reso conto che i f("","1")rendimenti "", che è uguale al primo input ... forse questo dovrebbe essere aggiunto come un altro caso di test
Slow loris

2

Java 8, 119 byte

Lambda (al curry) da Stringa lambda da Stringa String. Assegna a Function<String, Function<String, String>>.

s->t->{String r=s.length()>t.length()?s:t;while((s+t).contains(r))r=r.substring(1)+(char)(Math.random()*128);return r;}

Provalo online

Lambda ungolfed

s ->
    t -> {
        String r = s.length() > t.length() ? s : t;
        while ((s + t).contains(r))
            r = r.substring(1) + (char) (Math.random() * 128);
        return r;
    }

Questa soluzione ruota i caratteri ASCII casuali nella stringa più lunga fino a quando le condizioni richieste sono soddisfatte. Gli ingressi sono UTF-8 e le uscite sono ASCII.

Non conosco i dettagli grintosi di Unicode, ma mi sembra plausibile che questa soluzione potrebbe fallire quando un allegato si charunisce al punto di codice precedente per formare una singola unità di codice. Se qualcuno che ne è a conoscenza può verificarlo, cambierò il dominio di input in ASCII.

Java 8, 126 byte

Stesso tipo di sopra.

s->t->{String r;for(byte[]o=(s.length()>t.length()?s:t).getBytes();(s+t).contains(r=new String(o));o[0]%=128)o[0]++;return r;}

Provalo online

Lambda ungolfed

s ->
    t -> {
        String r;
        for (
            byte[] o = (s.length() > t.length() ? s : t).getBytes();
            (s + t).contains(r = new String(o));
            o[0] %= 128
        )
            o[0]++;
        return r;
    }

Ciò incrementa il primo byte della stringa più lunga, avvolgendosi all'interno di ASCII, fino a quando non vengono soddisfatte le condizioni richieste. Ingressi e uscite sono stringhe ASCII.


1
Dato l'output del tuo terzo caso di test, genera una stringa di lunghezza tre: provalo online!
Stephen,

Ah, merda. Ora dovrò imparare come funziona Unicode per risolvere questo problema senza esplodere il conteggio dei byte ...
Jakob


2

Bash, 115 .. 77 byte

Sostituisce il primo carattere della prima stringa di input (non vuota) con 1,2,3 fino a quando non viene trovata alcuna corrispondenza per nessuno dei due input. Provalo online!

-9, -12, -9, -8 byte grazie a GammaFunction

x="${1:-$2}"
for s in {1..3}"${x:1}"
{ [[ $s = @($1|$2) ]]||break;}
echo "$s"

(un bel miglioramento rispetto all'originale ... )


1
Bel metodo! È possibile utilizzare =e ||nell'ultima riga e utilizzare ${x:-empty_fallback}per rimuovere il ternario iniziale. Inoltre, hai bisogno di virgolette sull'eco finale per il caso di spazi finali. TIO obbligatorio
Funzione gamma


1
Mi piace quello che stai cercando con shift, l' ho preso per legare il mio metodo in due metodi diversi .
Funzione gamma




1

Japt , 17 byte

;B¬£ñl g1 çXÃkU v

Ripete le lettere A-Zper la lunghezza dell'input più lungo, rimuove i valori nell'input e ottiene il primo elemento dell'array.

Provalo online!

Vecchia soluzione, 18 byte

;@!UøX}a@ñl g1 çBö

Provalo online!

Scegli un carattere casuale dall'alfabeto e lo ripete per la lunghezza della stringa di input più lunga, fino a quando non è presente nell'input.


Fallito per ["abcdefghijklmnopqrstuvwxyz", "AAAAAAAAAAAAAAAAAAAAAAAAAA"]. Quando lo "AAAAAAAAAAAAAAAAAAAAAAAAAA"
eseguivo

Non riesce per ["D", ""]. se lo esegui più volte otterrai "D"
J42161217

Grazie, ho pensato che ci fossero alcuni casi che non avevo testato. Risolto per solo +1 byte.
Justin Mariner,

Ìdovrebbe funzionare al posto di g1 per un salvataggio di 2 byte (in un array di 2 elementi g1= gJ) ma sembra che ci sia un bug con Ìquando si usa ;.
Shaggy,

@Shaggy Sì, penso che la causa Jnon sia più -1dovuta al fatto di ;cambiarla ,. Ecco perché ho usato 1in primo luogo.
Justin Mariner,

1

Python 3, 74 73 byte

-1 byte grazie a Step Hen

def f(x,y,i=1):
 while i*10<10**len(x or y)or str(i)in x+y:i*=2
 print(i)

Stampa il numero intero più basso con la stessa lunghezza del primo degli input con lunghezza diversa da zero.


Salvare un byte con icome parametro funzione predefinita: def f(x,y,i=1):. Penso che puoi salvare un altro byte con while10*ima non ne sono sicuro.
Stephen,

È possibile sostituire while i*10<10**len(x or y)or str(i)in x+ycon while i<10**~-len(x or y)or str(i)in x+y ( 72 byte )
Mr. Xcoder

E puoi anche usare la ricorsione per salvare byte: f=lambda x,y,i=1:(i<10**~-len(x or y)or str(i)in x+y)and f(x,y,i*2)or i( 71 byte )
Mr. Xcoder

1

Python 2, 77 byte

a=input()
b=ord(a[0][0])+1
if b==ord(a[1][0]):b+=1
print unichr(b)+a[0][1:-1]

Penso che abbia qualche potenziale. L'idea è che aggiunge 1 al 1 ° carattere nella 1 ° stringa, quindi controlla se il 1 ° carattere dell'altro input è lo stesso.

** Nota, ^ non gestisce stringhe di lunghezza 0, quindi non funziona davvero a questa lunghezza.

Ecco una soluzione super lunga che funziona con lunghezza 0

146 byte

a=input()
def c(i):print unichr(ord(a[i][0])+1)+a[i][1:];exit();
for x in range(2):if len(a[x-1])<1:c(x)
if a[0]==a[1]:c(1)
print a[1][0]+a[0][1:]

Eventuali miglioramenti sarebbero apprezzati!


1

CJam, 31 30 23 byte

q~:A:e>,3,sf*{A\f=:+!}=

Utilizza ASCII stampabile come input. Emette una stringa di 0, 1 o 2 che ha la stessa lunghezza di una delle stringhe di input. La logica è che una di quelle non può essere una delle stringhe di input!

Provalo online

q~:A    e# Store input array as var 'A'
:e>,    e# Take the length of the lexicographically greater string in the input array
3,s     e# Generate "012"
f*      e# Repeat each number as many times as the longer string length, yielding something like ["000","111","222"]
{       e# Search array of number strings for first that returns true for this function
A\f=    e# Map each string in the input array to whether it equals the current number string (0,1)
:+!     e# Add up the array of bits and take the logical not. This returns true iff both array values were not equal to the current number string.
}=      e# Return the first number string that returns true.

Qualcuno ha qualche idea su come restituire vero solo se entrambi i bit dell'array sono falsi (NOR)? Attualmente lo sto facendo :+!.
geokavel,

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.