Comment écrire un exemple d'implémentation du problème dans E05 (ruby, C11) en temps réel hors ligne

Problème http://nabetani.sakura.ne.jp/hena/orde05dokitruck/ Liens d'implémentation http://qiita.com/Nabetani/items/c516875b13a4d282affe est.

alors.

Il existe plusieurs politiques de mise en œuvre.

• Que ce soit pour aller de la droite ou de la gauche.
• Allez-vous un par un ou tous à la fois?
• De quoi avoir les données

Je vais choisir librement.

J'ai calculé par derrière à la fois, et les données sont un peu.

Premièrement, implémentation par C11 ou C99:

// clang -std=c11 -Wall
// clang x86_64-apple-darwin15.5.0
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <memory.h>

char * build_ans( int s )
{
  char * r = calloc(4, 1);
  for( int i=0 ; i<3 ; ++i ){
    if ( s&(1<<i) ){
      strcat( r, (char[2]){'a'+i});
    }
  }
  if ( !*r ){
    r[0]='-';
  }
  return r;
}

char * solve( char const * src )
{
  int s=7;
  for( char const * it = src + strlen( src ) -1 ; src<=it ; --it ){
    switch(*it-'0'){
    case 1: s|=s/2; break;
    case 2: s|=(s&2)*2+!!(s&4); break;
    case 3: s|=!!(s&4)+(s&1)*2; break;
    case 4: s|=s*2; break;
    case 5: s|=(s&1)*4+(s&4)/2; break;
    case 6: s|=(s&1)*4+!!(s&2); break;
    case 7: s&=5; break;
    case 8: s&=6; break;
    case 9: s&=3; break;
    }
  }
  return build_ans(s);
}

void test( char const * src, char const * expected )
{
  char const * actual = solve( src );
  bool okay = 0==strcmp( actual, expected );
  printf( "%s %s->%s ( e:%s )\n", ( okay ? "ok" : "**NG**" ), src, actual , expected );
  free( actual );
}

int main()
{
  /*0*/ test( "1728398", "bc" );    
  //Abréviation
  /*36*/ test( "697535114542", "ac" );
  return 0;
}

Comme d'habitude, la plupart des données de test sont omises.

Puisqu'il y a trois états, la vie et la mort, elle peut être exprimée en 3 bits. Puisque la vie est fixée à 1, "& =" apporte la mort et "| =" augmente la possibilité de vivre.

L'intérieur de résoudre est foiré, mais il ne peut pas être aidé car il exprime le désordre des blocs qui composent le cours. Ce serait cool de l'avoir dans les données, mais cette fois, c'est exprimé en code. Pour rappel, "!!" signifie un calcul à l'effet que le refus logique est effectué deux fois et non nul est mis à 1.

Ce qui suit est un calcul écrit en rubis avec exactement le même but. Ou plutôt, je l'ai écrit en rubis plus tôt.

def apply( s, c )
  case c
  when "0";    s
  when "1";    s | s[1] | s[2]*2
  when "2";    s | s[1]*4 | s[2]
  when "3";    s | s[0]*2 | s[2]
  when "4";    s | s[0]*2 | s[1]*4
  when "5";    s | s[0]*4 | s[2]*2
  when "6";    s | s[0]*4 | s[1]
  when "7";    s & 5
  when "8";    s & 6
  when "9";    s & 3
  end
end

def solve( src )
  r=src.chars.reverse.inject(7) do |s,c|
    apply( s, c )
  end
  %w( a b c ).each.with_index(0).map{ |c,ix|
    r[ix]==0 ? "" : c
  }.join.tap{ |x| return x.empty? ? "-" : x }
end

$stdout.sync=true

DATA.map do |line|
  num, src, expected = line.split(/\s+/)
  actual = solve( src )
  okay = actual==expected
  puts( "%s %2d %s->%s ( e:%s )" % [ ( okay ? "ok" : "**NG**" ), num, src, actual, expected ] )
  okay
end.all?.tap{|x| puts( x ? "everything is ok" : "something wrong" ) }

__END__
0 1728398 bc  
1 789 - 
2 274 ac  
3 185 abc 

36  697535114542  ac  

Même les opérations sur les bits sont plus faciles à écrire avec ruby.